Clarified some debug messages

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(nullptr) {
+		owner(setOwner), queueToUse(useThisQueue), ipcStore(
+				NULL) {
 }
 
 ActionHelper::~ActionHelper() {
@@ -16,18 +16,16 @@ ReturnValue_t ActionHelper::handleActionMessage(CommandMessage* command) {
 				ActionMessage::getStoreId(command));
 		return HasReturnvaluesIF::RETURN_OK;
 	} else {
-		return CommandMessage::UNKNOWN_COMMAND;
+		return CommandMessage::UNKNOW_COMMAND;
 	}
 }
 
 ReturnValue_t ActionHelper::initialize(MessageQueueIF* queueToUse_) {
 	ipcStore = objectManager->get<StorageManagerIF>(objects::IPC_STORE);
-	if (ipcStore == nullptr) {
+	if (ipcStore == NULL) {
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}
-	if(queueToUse_ != nullptr) {
-		setQueueToUse(queueToUse_);
-	}
+	setQueueToUse(queueToUse_);
 
 	return HasReturnvaluesIF::RETURN_OK;
 }
@@ -69,23 +67,22 @@ 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;
-	size_t maxSize = data->getSerializedSize();
+	uint32_t maxSize = data->getSerializedSize();
 	if (maxSize == 0) {
 		//No error, there's simply nothing to report.
 		return HasReturnvaluesIF::RETURN_OK;
 	}
-	size_t size = 0;
+	uint32_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);
+	result = data->serialize(&dataPtr, &size, maxSize, true);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		ipcStore->deleteData(storeAddress);
 		return result;

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_ = nullptr);
+	ReturnValue_t initialize(MessageQueueIF* queueToUse_);
 	/**
 	 * Function to be called from the owner to send a step message. Success or failure will be determined by the result value.
 	 *

action/ActionMessage.h

@@ -10,7 +10,7 @@ class ActionMessage {
 private:
 	ActionMessage();
 public:
-	static const uint8_t MESSAGE_ID = messagetypes::ACTION;
+	static const uint8_t MESSAGE_ID = MESSAGE_TYPE::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);

action/CommandActionHelper.cpp

@@ -4,31 +4,30 @@
 #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;
-	size_t maxSize = data->getSerializedSize();
+	uint8_t* storePointer;
+	uint32_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);
+	uint32_t size = 0;
+	result = data->serialize(&storePointer, &size, maxSize, true);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}
@@ -36,11 +35,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;
 	}
@@ -72,13 +71,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;
 	}
@@ -89,8 +88,7 @@ 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),
@@ -98,13 +96,11 @@ 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;

action/HasActionsIF.h

@@ -1,5 +1,5 @@
-#ifndef FRAMEWORK_ACTION_HASACTIONSIF_H_
-#define FRAMEWORK_ACTION_HASACTIONSIF_H_
+#ifndef HASACTIONSIF_H_
+#define HASACTIONSIF_H_
 
 #include <framework/action/ActionHelper.h>
 #include <framework/action/ActionMessage.h>
@@ -7,35 +7,27 @@
 #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.
+ * 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
+ * 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.
  */
 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);
@@ -47,14 +39,12 @@ 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!
+	 * 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, uint32_t size) = 0;
 };
 
 
-#endif /* FRAMEWORK_ACTION_HASACTIONSIF_H_ */
+#endif /* HASACTIONSIF_H_ */

container/ArrayList.h

@@ -1,15 +1,15 @@
-#ifndef FRAMEWORK_CONTAINER_ARRAYLIST_H_
-#define FRAMEWORK_CONTAINER_ARRAYLIST_H_
+#ifndef ARRAYLIST_H_
+#define 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.
+ * 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.
+ *
  *
  * @ingroup container
  */
@@ -20,13 +20,81 @@ 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;
+	/**
+	 * 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);
+		}
+	}
+	;
 
 	/**
 	 * Number of Elements stored in this List
@@ -67,78 +135,6 @@ 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
 	 *
@@ -227,7 +223,19 @@ public:
 	count_t remaining() {
 		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
@@ -242,6 +250,6 @@ protected:
 	 * true if the array was allocated and needs to be deleted in the destructor.
 	 */
 	bool allocated;
-};
 
+};
 #endif /* ARRAYLIST_H_ */

container/DynamicFIFO.h

@@ -1,42 +0,0 @@
-#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_ */

container/FIFO.h

@@ -1,34 +1,82 @@
-#ifndef FRAMEWORK_CONTAINER_FIFO_H_
-#define FRAMEWORK_CONTAINER_FIFO_H_
+#ifndef FIFO_H_
+#define 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.
+ * @brief Simple First-In-First-Out data structure
  * @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) {};
+template<typename T, uint8_t capacity>
+class FIFO {
+private:
+	uint8_t readIndex, writeIndex, currentSize;
+	T data[capacity];
 
-	/**
-	 * @brief 	Custom copy constructor to set pointer correctly.
-	 * @param other
-	 */
-	FIFO(const FIFO& other): FIFOBase<T>(other) {
-		this->setData(fifoArray.data());
+	uint8_t next(uint8_t current) {
+		++current;
+		if (current == capacity) {
+			current = 0;
+		}
+		return current;
+	}
+public:
+	FIFO() :
+			readIndex(0), writeIndex(0), currentSize(0) {
 	}
 
-private:
-	std::array<T, capacity> fifoArray;
+	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);
 };
 
-#endif /* FRAMEWORK_CONTAINERS_STATICFIFO_H_ */
+#endif /* FIFO_H_ */

container/FIFOBase.h

@@ -1,65 +0,0 @@
-#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_ */

container/FIFOBase.tpp

@@ -1,87 +0,0 @@
-#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):
-		maxCapacity(maxCapacity), values(values){};
-
-template<typename T>
-inline ReturnValue_t FIFOBase<T>::insert(T value) {
-	if (full()) {
-		return FULL;
-	} else {
-		values[writeIndex] = value;
-		writeIndex = next(writeIndex);
-		++currentSize;
-		return HasReturnvaluesIF::RETURN_OK;
-	}
-};
-
-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;
-}
-
-template<typename T>
-inline size_t FIFOBase<T>::getMaxCapacity() const {
-	return maxCapacity;
-}
-
-
-template<typename T>
-inline void FIFOBase<T>::setData(T *data) {
-	this->values = data;
-}
-
-#endif

container/FixedArrayList.h

@@ -2,41 +2,18 @@
 #define FIXEDARRAYLIST_H_
 
 #include <framework/container/ArrayList.h>
-
 /**
- * @brief 	Array List with a fixed maximum size
- * @ingroup container
+ * \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));

container/FixedMap.h

@@ -6,11 +6,7 @@
 #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
+ * \ingroup container
  */
 template<typename key_t, typename T>
 class FixedMap: public SerializeIF {
@@ -56,24 +52,12 @@ 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]);
 	}
@@ -88,10 +72,10 @@ public:
 
 	ReturnValue_t insert(key_t key, T value, Iterator *storedValue = NULL) {
 		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;
@@ -103,7 +87,7 @@ public:
 	}
 
 	ReturnValue_t insert(std::pair<key_t, T> pair) {
-		return insert(pair.first, pair.second);
+		return insert(pair.fist, pair.second);
 	}
 
 	ReturnValue_t exists(key_t key) const {
@@ -164,57 +148,47 @@ 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,
-				buffer, size, maxSize, streamEndianness);
+	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,
+				buffer, size, max_size, bigEndian);
 		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);
+			result = SerializeAdapter<key_t>::serialize(&theMap[i].first, buffer,
+					size, max_size, bigEndian);
+			result = SerializeAdapter<T>::serialize(&theMap[i].second, buffer, size,
+					max_size, bigEndian);
 			++i;
 		}
 		return result;
 	}
 
-	virtual size_t getSerializedSize() const {
+	virtual uint32_t getSerializedSize() const {
 		uint32_t printSize = sizeof(_size);
 		uint32_t i = 0;
 
 		for (i = 0; i < _size; ++i) {
-			printSize += SerializeAdapter::getSerializedSize(
+			printSize += SerializeAdapter<key_t>::getSerializedSize(
 					&theMap[i].first);
-			printSize += SerializeAdapter::getSerializedSize(&theMap[i].second);
+			printSize += SerializeAdapter<T>::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);
+	virtual ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size,
+			bool bigEndian) {
+		ReturnValue_t result = SerializeAdapter<uint32_t>::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::deSerialize(&theMap[i].first, buffer,
-					size, streamEndianness);
-			result = SerializeAdapter::deSerialize(&theMap[i].second, buffer, size,
-					streamEndianness);
+			result = SerializeAdapter<key_t>::deSerialize(&theMap[i].first, buffer,
+					size, bigEndian);
+			result = SerializeAdapter<T>::deSerialize(&theMap[i].second, buffer, size,
+					bigEndian);
 			++i;
 		}
 		return result;

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_MULTIMAP;
+	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);

container/HybridIterator.h

@@ -1,5 +1,5 @@
-#ifndef FRAMEWORK_CONTAINER_HYBRIDITERATOR_H_
-#define FRAMEWORK_CONTAINER_HYBRIDITERATOR_H_
+#ifndef HYBRIDITERATOR_H_
+#define HYBRIDITERATOR_H_
 
 #include <framework/container/ArrayList.h>
 #include <framework/container/SinglyLinkedList.h>
@@ -8,32 +8,34 @@ template<typename T, typename count_t = uint8_t>
 class HybridIterator: public LinkedElement<T>::Iterator,
 		public ArrayList<T, count_t>::Iterator {
 public:
-	HybridIterator() {}
+	HybridIterator() :
+			value(NULL), linked(NULL), end(NULL) {
+	}
 
 	HybridIterator(typename LinkedElement<T>::Iterator *iter) :
-		LinkedElement<T>::Iterator(*iter), value(iter->value),
-		linked(true) {
+		LinkedElement<T>::Iterator(*iter), value(
+					iter->value), linked(true), end(NULL) {
 
 	}
 
 	HybridIterator(LinkedElement<T> *start) :
-		LinkedElement<T>::Iterator(start), value(start->value),
-		linked(true) {
+		LinkedElement<T>::Iterator(start), value(
+					start->value), linked(true), end(NULL) {
 
 	}
 
 	HybridIterator(typename ArrayList<T, count_t>::Iterator start,
 			typename ArrayList<T, count_t>::Iterator end) :
-			ArrayList<T, count_t>::Iterator(start), value(start.value),
-			linked(false), end(end.value) {
+			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 +44,17 @@ public:
 	HybridIterator& operator++() {
 		if (linked) {
 			LinkedElement<T>::Iterator::operator++();
-			if (LinkedElement<T>::Iterator::value != nullptr) {
+			if (LinkedElement<T>::Iterator::value != NULL) {
 				value = LinkedElement<T>::Iterator::value->value;
 			} else {
-				value = nullptr;
+				value = NULL;
 			}
 		} else {
 			ArrayList<T, count_t>::Iterator::operator++();
 			value = ArrayList<T, count_t>::Iterator::value;
 
 			if (value == end) {
-				value = nullptr;
+				value = NULL;
 			}
 		}
 		return *this;
@@ -64,11 +66,11 @@ public:
 		return tmp;
 	}
 
-	bool operator==(const HybridIterator& other) const {
-		return value == other.value;
+	bool operator==(HybridIterator other) {
+		return value == other->value;
 	}
 
-	bool operator!=(const HybridIterator& other) const {
+	bool operator!=(HybridIterator other) {
 		return !(*this == other);
 	}
 
@@ -80,11 +82,11 @@ public:
 		return value;
 	}
 
-	T* value = nullptr;
+	T* value;
 
 private:
-	bool linked = false;
-	T *end = nullptr;
+	bool linked;
+	T *end;
 };
 
-#endif /* FRAMEWORK_CONTAINER_HYBRIDITERATOR_H_ */
+#endif /* HYBRIDITERATOR_H_ */

container/IndexedRingMemoryArray.h

@@ -8,27 +8,20 @@
 #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{
 	/**
-	 *
+	 * 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;
 	}
 	/**
@@ -75,50 +68,50 @@ public:
 		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);
+	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);
 		if(result != HasReturnvaluesIF::RETURN_OK){
 			return result;
 		}
-		result = indexType.serialize(buffer,size,maxSize,streamEndianness);
+		result = indexType.serialize(buffer,size,max_size,bigEndian);
 		if(result != HasReturnvaluesIF::RETURN_OK){
 			return result;
 		}
-		result = SerializeAdapter::serialize(&this->size,buffer,size,maxSize,streamEndianness);
+		result = AutoSerializeAdapter::serialize(&this->size,buffer,size,max_size,bigEndian);
 		if(result != HasReturnvaluesIF::RETURN_OK){
 			return result;
 		}
-		result = SerializeAdapter::serialize(&this->storedPackets,buffer,size,maxSize,streamEndianness);
+		result = AutoSerializeAdapter::serialize(&this->storedPackets,buffer,size,max_size,bigEndian);
 		return result;
 	}
 
-	ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
-				Endianness streamEndianness){
-		ReturnValue_t result = SerializeAdapter::deSerialize(&blockStartAddress,buffer,size,streamEndianness);
+	ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size,
+				bool bigEndian){
+		ReturnValue_t result = AutoSerializeAdapter::deSerialize(&blockStartAddress,buffer,size,bigEndian);
 		if(result != HasReturnvaluesIF::RETURN_OK){
 			return result;
 		}
-		result = indexType.deSerialize(buffer,size,streamEndianness);
+		result = indexType.deSerialize(buffer,size,bigEndian);
 		if(result != HasReturnvaluesIF::RETURN_OK){
 			return result;
 		}
-		result = SerializeAdapter::deSerialize(&this->size,buffer,size,streamEndianness);
+		result = AutoSerializeAdapter::deSerialize(&this->size,buffer,size,bigEndian);
 		if(result != HasReturnvaluesIF::RETURN_OK){
 			return result;
 		}
-		result = SerializeAdapter::deSerialize(&this->storedPackets,buffer,size,streamEndianness);
+		result = AutoSerializeAdapter::deSerialize(&this->storedPackets,buffer,size,bigEndian);
 		if(result != HasReturnvaluesIF::RETURN_OK){
 			return result;
 		}
 		return result;
 	}
 
-	size_t getSerializedSize() const {
-		uint32_t size = SerializeAdapter::getSerializedSize(&blockStartAddress);
+	uint32_t getSerializedSize() const {
+		uint32_t size = AutoSerializeAdapter::getSerializedSize(&blockStartAddress);
 		size += indexType.getSerializedSize();
-		size += SerializeAdapter::getSerializedSize(&this->size);
-		size += SerializeAdapter::getSerializedSize(&this->storedPackets);
+		size += AutoSerializeAdapter::getSerializedSize(&this->size);
+		size += AutoSerializeAdapter::getSerializedSize(&this->storedPackets);
 		return size;
 	}
 
@@ -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);
 	}
 
@@ -509,37 +485,37 @@ public:
 	 * Parameters according to HasSerializeIF
 	 * @param buffer
 	 * @param size
-	 * @param maxSize
-	 * @param streamEndianness
+	 * @param max_size
+	 * @param bigEndian
 	 * @return
 	 */
-	ReturnValue_t serialize(uint8_t** buffer, size_t* size,
-				size_t maxSize, Endianness streamEndianness) const{
+	ReturnValue_t serialize(uint8_t** buffer, uint32_t* size,
+				const uint32_t max_size, bool bigEndian) const{
 		uint8_t* crcBuffer = *buffer;
 		uint32_t oldSize = *size;
 		if(additionalInfo!=NULL){
-			additionalInfo->serialize(buffer,size,maxSize,streamEndianness);
+			additionalInfo->serialize(buffer,size,max_size,bigEndian);
 		}
-		ReturnValue_t result = currentWriteBlock->serialize(buffer,size,maxSize,streamEndianness);
+		ReturnValue_t result = currentWriteBlock->serialize(buffer,size,max_size,bigEndian);
 		if(result != HasReturnvaluesIF::RETURN_OK){
 					return result;
 		}
-		result = SerializeAdapter::serialize(&this->size,buffer,size,maxSize,streamEndianness);
+		result = AutoSerializeAdapter::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::serialize(&this->entries[i], buffer, size,
-					maxSize, streamEndianness);
+			result = SerializeAdapter<Index<T> >::serialize(&this->entries[i], buffer, size,
+					max_size, bigEndian);
 			++i;
 		}
 		if(result != HasReturnvaluesIF::RETURN_OK){
 			return result;
 		}
 		uint16_t crc = Calculate_CRC(crcBuffer,(*size-oldSize));
-		result = SerializeAdapter::serialize(&crc,buffer,size,maxSize,streamEndianness);
+		result = AutoSerializeAdapter::serialize(&crc,buffer,size,max_size,bigEndian);
 		return result;
 	}
 
@@ -548,17 +524,17 @@ public:
 	 * Get the serialized Size of the index
 	 * @return The serialized size of the index
 	 */
-	size_t getSerializedSize() const {
+	uint32_t getSerializedSize() const {
 
-		size_t size = 0;
+		uint32_t size = 0;
 		if(additionalInfo!=NULL){
 			size += additionalInfo->getSerializedSize();
 		}
 		size += currentWriteBlock->getSerializedSize();
-		size += SerializeAdapter::getSerializedSize(&this->size);
+		size += AutoSerializeAdapter::getSerializedSize(&this->size);
 		size += (this->entries[0].getSerializedSize()) * this->size;
 		uint16_t crc = 0;
-		size += SerializeAdapter::getSerializedSize(&crc);
+		size += AutoSerializeAdapter::getSerializedSize(&crc);
 		return size;
 	}
 	/**
@@ -566,28 +542,28 @@ public:
 	 * CRC Has to be checked before!
 	 * @param buffer
 	 * @param size
-	 * @param streamEndianness
+	 * @param bigEndian
 	 * @return
 	 */
 
-	ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
-				Endianness streamEndianness){
+	ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size,
+				bool bigEndian){
 
 		ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
 		if(additionalInfo!=NULL){
-			result = additionalInfo->deSerialize(buffer,size,streamEndianness);
+			result = additionalInfo->deSerialize(buffer,size,bigEndian);
 		}
 		if(result != HasReturnvaluesIF::RETURN_OK){
 					return result;
 		}
 
 		Index<T> tempIndex;
-		result = tempIndex.deSerialize(buffer,size,streamEndianness);
+		result = tempIndex.deSerialize(buffer,size,bigEndian);
 		if(result != HasReturnvaluesIF::RETURN_OK){
 					return result;
 		}
 		uint32_t tempSize = 0;
-		result = SerializeAdapter::deSerialize(&tempSize,buffer,size,streamEndianness);
+		result = AutoSerializeAdapter::deSerialize(&tempSize,buffer,size,bigEndian);
 		if(result != HasReturnvaluesIF::RETURN_OK){
 					return result;
 		}
@@ -596,9 +572,9 @@ public:
 		}
 		uint32_t i = 0;
 		while ((result == HasReturnvaluesIF::RETURN_OK) && (i < this->size)) {
-			result = SerializeAdapter::deSerialize(
+			result = SerializeAdapter<Index<T> >::deSerialize(
 					&this->entries[i], buffer, size,
-					streamEndianness);
+					bigEndian);
 			++i;
 		}
 		if(result != HasReturnvaluesIF::RETURN_OK){
@@ -718,4 +694,7 @@ private:
 
 };
 
+
+
+
 #endif /* FRAMEWORK_CONTAINER_INDEXEDRINGMEMORY_H_ */

container/IsDerivedFrom.h

@@ -1,13 +1,6 @@
 #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 {
@@ -16,9 +9,7 @@ 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:

container/RingBufferBase.h

@@ -2,76 +2,16 @@
 #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) {
+	RingBufferBase(uint32_t startAddress, uint32_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);
@@ -80,34 +20,77 @@ protected:
 			return HasReturnvaluesIF::RETURN_FAILED;
 		}
 	}
-
 	ReturnValue_t writeData(uint32_t amount) {
-		if (availableWriteSpace() >= amount or overwriteOld) {
+		if (availableWriteSpace() >= amount || overwriteOld) {
 			incrementWrite(amount);
 			return HasReturnvaluesIF::RETURN_OK;
 		} else {
 			return HasReturnvaluesIF::RETURN_FAILED;
 		}
 	}
+	uint32_t availableReadData(uint8_t n = 0) const {
+		return ((write + size) - read[n]) % size;
+	}
+	uint32_t availableWriteSpace(uint8_t n = 0) const  {
+		//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() {
 
-
-	size_t getRead(uint8_t n = 0) const {
+	}
+	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() {
+		return (start + size) - write;
+	}
+	uint32_t readTillWrap(uint8_t n = 0) {
+		return (start + size) - read[n];
+	}
+	uint32_t getStart() const {
+		return start;
+	}
+	bool overwritesOld() const {
+		return overwriteOld;
+	}
+	uint32_t maxSize() const {
+		return size - 1;
+	}
+protected:
+	const uint32_t start;
+	uint32_t write;
+	uint32_t read[N_READ_PTRS];
+	const uint32_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;
+	}
 };
 
 #endif /* FRAMEWORK_CONTAINER_RINGBUFFERBASE_H_ */

container/SharedRingBuffer.cpp

@@ -1,59 +0,0 @@
-#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, 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, 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);
-	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);
-	return SimpleRingBuffer::readData(data,amount, incrementReadPtr,
-			readRemaining, trueAmount);
-}
-
-ReturnValue_t SharedRingBuffer::deleteDataProtected(size_t amount,
-		bool deleteRemaining, size_t *trueAmount) {
-	MutexHelper(mutex, mutexTimeout);
-	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;
-}

container/SharedRingBuffer.h

@@ -1,68 +0,0 @@
-#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>
-
-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,
-			dur_millis_t mutexTimeout = 10);
-
-	/**
-	 * This constructor takes an external buffer with the specified size.
-	 * @param buffer
-	 * @param size
-	 * @param overwriteOld
-	 * If the ring buffer is overflowing at a write operartion, the oldest data
-	 * will be overwritten.
-	 */
-	SharedRingBuffer(object_id_t objectId, uint8_t* buffer, const size_t size,
-			bool overwriteOld, size_t maxExcessBytes,
-			dur_millis_t mutexTimeout = 10);
-
-	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);
-
-	/** 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;
-private:
-	dur_millis_t mutexTimeout;
-	MutexIF* mutex = nullptr;
-};
-
-
-
-#endif /* FRAMEWORK_CONTAINER_SHAREDRINGBUFFER_H_ */

container/SimpleRingBuffer.cpp

@@ -1,64 +1,22 @@
 #include <framework/container/SimpleRingBuffer.h>
-#include <cstring>
+#include <string.h>
 
-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(uint32_t size, bool overwriteOld) :
+		RingBufferBase<>(0, size, overwriteOld), buffer(NULL) {
+	buffer = new uint8_t[size];
 }
 
-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();
+		uint32_t amount) {
+	if (availableWriteSpace() >= amount || overwriteOld) {
+		uint32_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);
 		}
@@ -69,19 +27,18 @@ 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 amountTillWrap = readTillWrap(READ_PTR);
+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);
 	if (availableData < amount) {
 		if (readRemaining) {
-			// more data available than amount specified.
 			amount = availableData;
 		} else {
 			return HasReturnvaluesIF::RETURN_FAILED;
 		}
 	}
-	if (trueAmount != nullptr) {
+	if (trueAmount != NULL) {
 		*trueAmount = amount;
 	}
 	if (amountTillWrap >= amount) {
@@ -90,27 +47,12 @@ ReturnValue_t SimpleRingBuffer::readData(uint8_t* data, size_t amount,
 		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);
+ReturnValue_t SimpleRingBuffer::deleteData(uint32_t amount,
+		bool deleteRemaining, uint32_t* trueAmount) {
+	uint32_t availableData = availableReadData(READ_PTR);
 	if (availableData < amount) {
 		if (deleteRemaining) {
 			amount = availableData;
@@ -118,10 +60,9 @@ ReturnValue_t SimpleRingBuffer::deleteData(size_t amount,
 			return HasReturnvaluesIF::RETURN_FAILED;
 		}
 	}
-	if (trueAmount != nullptr) {
+	if (trueAmount != NULL) {
 		*trueAmount = amount;
 	}
 	incrementRead(amount, READ_PTR);
 	return HasReturnvaluesIF::RETURN_OK;
 }
-

container/SimpleRingBuffer.h

@@ -2,117 +2,19 @@
 #define FRAMEWORK_CONTAINER_SIMPLERINGBUFFER_H_
 
 #include <framework/container/RingBufferBase.h>
-#include <cstddef>
+#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.
- * 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);
-
+	SimpleRingBuffer(uint32_t size, bool overwriteOld);
 	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);
+	ReturnValue_t writeData(const uint8_t* data, uint32_t amount);
+	ReturnValue_t readData(uint8_t* data, uint32_t amount, bool readRemaining = false, uint32_t* trueAmount = NULL);
+	ReturnValue_t deleteData(uint32_t amount, bool deleteRemaining = false, uint32_t* trueAmount = NULL);
 private:
+//	static const uint8_t TEMP_READ_PTR = 1;
 	static const uint8_t READ_PTR = 0;
-	uint8_t* buffer = nullptr;
-	size_t maxExcessBytes;
-	size_t excessBytes = 0;
+	uint8_t* buffer;
 };
 
 #endif /* FRAMEWORK_CONTAINER_SIMPLERINGBUFFER_H_ */

container/SinglyLinkedList.h

@@ -1,13 +1,10 @@
-#ifndef FRAMEWORK_CONTAINER_SINGLYLINKEDLIST_H_
-#define FRAMEWORK_CONTAINER_SINGLYLINKEDLIST_H_
-
-#include <cstddef>
-#include <cstdint>
+#ifndef SINGLYLINKEDLIST_H_
+#define SINGLYLINKEDLIST_H_
 
+#include <stddef.h>
+#include <stdint.h>
 /**
- * @brief	Linked list data structure,
- * 			each entry has a pointer to the next entry (singly)
- * @ingroup container
+ * \ingroup container
  */
 template<typename T>
 class LinkedElement {
@@ -15,8 +12,11 @@ public:
 	T *value;
 	class Iterator {
 	public:
-		LinkedElement<T> *value = nullptr;
-		Iterator() {}
+		LinkedElement<T> *value;
+		Iterator() :
+				value(NULL) {
+
+		}
 
 		Iterator(LinkedElement<T> *element) :
 				value(element) {
@@ -45,11 +45,12 @@ public:
 		}
 	};
 
-	LinkedElement(T* setElement, LinkedElement<T>* setNext = nullptr):
-	       value(setElement), next(setNext) {}
-
-	virtual ~LinkedElement(){}
+	LinkedElement(T* setElement, LinkedElement<T>* setNext = NULL) : value(setElement),
+		next(setNext) {
+	}
+	virtual ~LinkedElement(){
 
+	}
 	virtual LinkedElement* getNext() const {
 		return next;
 	}
@@ -57,16 +58,11 @@ public:
 	virtual void setNext(LinkedElement* next) {
 		this->next = next;
 	}
-
-	virtual void setEnd() {
-	    this->next = nullptr;
-	}
-
 	LinkedElement* begin() {
 		return this;
 	}
 	LinkedElement* end() {
-		return nullptr;
+		return NULL;
 	}
 private:
 	LinkedElement *next;
@@ -75,80 +71,37 @@ private:
 template<typename T>
 class SinglyLinkedList {
 public:
-    using ElementIterator = typename LinkedElement<T>::Iterator;
-
-	SinglyLinkedList() {}
-
-	SinglyLinkedList(ElementIterator start) :
-			start(start.value) {}
+	SinglyLinkedList() :
+			start(NULL) {
+	}
 
+	SinglyLinkedList(typename LinkedElement<T>::Iterator start) :
+			start(start.value) {
+	}
 	SinglyLinkedList(LinkedElement<T>* startElement) :
-			start(startElement) {}
-
-	ElementIterator begin() const {
-		return ElementIterator::Iterator(start);
+				start(startElement) {
+		}
+	typename LinkedElement<T>::Iterator begin() const {
+		return LinkedElement<T>::Iterator::Iterator(start);
+	}
+	typename LinkedElement<T>::Iterator::Iterator end() const {
+		return LinkedElement<T>::Iterator::Iterator();
 	}
 
-	/** Returns iterator to nulltr */
-	ElementIterator end() const {
-		return ElementIterator::Iterator();
-	}
-
-	/**
-	 * Returns last element in singly linked list.
-	 * @return
-	 */
-	ElementIterator back() const {
-	    LinkedElement<T> *element = start;
-	    while (element != nullptr) {
-	        element = element->getNext();
-	    }
-	    return ElementIterator::Iterator(element);
-	}
-
-	size_t getSize() const {
-		size_t size = 0;
+	uint32_t getSize() const {
+		uint32_t size = 0;
 		LinkedElement<T> *element = start;
-		while (element != nullptr) {
+		while (element != NULL) {
 			size++;
 			element = element->getNext();
 		}
 		return size;
 	}
-	void setStart(LinkedElement<T>* firstElement) {
-		start = firstElement;
+	void setStart(LinkedElement<T>* setStart) {
+		start = setStart;
 	}
-
-	void setNext(LinkedElement<T>* currentElement,
-	        LinkedElement<T>* nextElement) {
-	    currentElement->setNext(nextElement);
-	}
-
-    void setLast(LinkedElement<T>* lastElement) {
-        lastElement->setEnd();
-    }
-
-    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;
+	LinkedElement<T> *start;
 };
 
 #endif /* SINGLYLINKEDLIST_H_ */

container/group.h

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

controller/ControllerBase.cpp

@@ -56,26 +56,26 @@ MessageQueueId_t ControllerBase::getCommandQueue() const {
 }
 
 void ControllerBase::handleQueue() {
-	CommandMessage command;
+	CommandMessage message;
 	ReturnValue_t result;
-	for (result = commandQueue->receiveMessage(&command); result == RETURN_OK;
-			result = commandQueue->receiveMessage(&command)) {
+	for (result = commandQueue->receiveMessage(&message); result == RETURN_OK;
+			result = commandQueue->receiveMessage(&message)) {
 
-		result = modeHelper.handleModeCommand(&command);
+		result = modeHelper.handleModeCommand(&message);
 		if (result == RETURN_OK) {
 			continue;
 		}
 
-		result = healthHelper.handleHealthCommand(&command);
+		result = healthHelper.handleHealthCommand(&message);
 		if (result == RETURN_OK) {
 			continue;
 		}
-		result = handleCommandMessage(&command);
+		result = handleCommandMessage(&message);
 		if (result == RETURN_OK) {
 			continue;
 		}
-		command.setToUnknownCommand();
-		commandQueue->reply(&command);
+		message.setToUnknownCommand();
+		commandQueue->reply(&message);
 	}
 
 }

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(nullptr), tcQueueId(MessageQueueMessageIF::NO_QUEUE) {
+		lastSegmentationFlag(NO_SEGMENTATION), mapId(setMapId), packetLength(0), bufferPosition(
+				packetBuffer), packetDestination(setPacketDestination), packetStore(
+				NULL), tcQueueId(MessageQueueSenderIF::NO_QUEUE) {
 	memset(packetBuffer, 0, sizeof(packetBuffer));
 }
 

datapool/ControllerSet.h

@@ -1,9 +1,9 @@
 #ifndef CONTROLLERSET_H_
 #define CONTROLLERSET_H_
 
-#include <framework/datapoolglob/GlobalDataSet.h>
+#include <framework/datapool/DataSet.h>
 
-class ControllerSet :public GlobDataSet {
+class ControllerSet :public DataSet {
 public:
 	ControllerSet();
 	virtual ~ControllerSet();

datapool/DataPool.cpp

@@ -0,0 +1,131 @@
+#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<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;
+}

datapool/DataPool.h

@@ -0,0 +1,135 @@
+/**
+ *	\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 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.
+ *	\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_ */

datapool/DataPoolAdmin.cpp

@@ -1,7 +1,7 @@
-#include <framework/datapoolglob/DataPoolAdmin.h>
-#include <framework/datapoolglob/GlobalDataSet.h>
-#include <framework/datapoolglob/GlobalDataPool.h>
-#include <framework/datapoolglob/PoolRawAccess.h>
+#include <framework/datapool/DataPool.h>
+#include <framework/datapool/DataPoolAdmin.h>
+#include <framework/datapool/DataSet.h>
+#include <framework/datapool/PoolRawAccess.h>
 #include <framework/ipc/CommandMessage.h>
 #include <framework/ipc/QueueFactory.h>
 #include <framework/parameters/ParameterMessage.h>
@@ -26,7 +26,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;
 	}
@@ -40,9 +40,9 @@ ReturnValue_t DataPoolAdmin::executeAction(ActionId_t actionId,
 
 	uint8_t valid = data[4];
 
-	uint32_t poolId = glob::dataPool.PIDToDataPoolId(address);
+	uint32_t poolId = ::dataPool.PIDToDataPoolId(address);
 
-	GlobDataSet mySet;
+	DataSet mySet;
 	PoolRawAccess variable(poolId, 0, &mySet, PoolVariableIF::VAR_READ_WRITE);
 	ReturnValue_t status = mySet.read();
 	if (status != RETURN_OK) {
@@ -91,10 +91,10 @@ void DataPoolAdmin::handleCommand() {
 }
 
 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;
+		const uint8_t* data, uint32_t size, uint8_t** dataPointer) {
+	uint32_t poolId = ::dataPool.PIDToDataPoolId(address);
+	uint8_t arrayIndex = ::dataPool.PIDToArrayIndex(address);
+	DataSet testSet;
 	PoolRawAccess varToGetSize(poolId, arrayIndex, &testSet,
 			PoolVariableIF::VAR_READ);
 	ReturnValue_t status = testSet.read();
@@ -113,7 +113,7 @@ ReturnValue_t DataPoolAdmin::handleMemoryLoad(uint32_t address,
 	const uint8_t* readPosition = data;
 
 	for (; size > 0; size -= typeSize) {
-		GlobDataSet rawSet;
+		DataSet rawSet;
 		PoolRawAccess variable(poolId, arrayIndex, &rawSet,
 				PoolVariableIF::VAR_READ_WRITE);
 		status = rawSet.read();
@@ -129,11 +129,11 @@ ReturnValue_t DataPoolAdmin::handleMemoryLoad(uint32_t address,
 	return ACTIVITY_COMPLETED;
 }
 
-ReturnValue_t DataPoolAdmin::handleMemoryDump(uint32_t address, size_t size,
+ReturnValue_t DataPoolAdmin::handleMemoryDump(uint32_t address, uint32_t size,
 		uint8_t** dataPointer, uint8_t* copyHere) {
-	uint32_t poolId = glob::dataPool.PIDToDataPoolId(address);
-	uint8_t arrayIndex = glob::dataPool.PIDToArrayIndex(address);
-	GlobDataSet testSet;
+	uint32_t poolId = ::dataPool.PIDToDataPoolId(address);
+	uint8_t arrayIndex = ::dataPool.PIDToArrayIndex(address);
+	DataSet testSet;
 	PoolRawAccess varToGetSize(poolId, arrayIndex, &testSet,
 			PoolVariableIF::VAR_READ);
 	ReturnValue_t status = testSet.read();
@@ -146,12 +146,12 @@ ReturnValue_t DataPoolAdmin::handleMemoryDump(uint32_t address, size_t size,
 	}
 	uint8_t* ptrToCopy = copyHere;
 	for (; size > 0; size -= typeSize) {
-		GlobDataSet rawSet;
+		DataSet rawSet;
 		PoolRawAccess variable(poolId, arrayIndex, &rawSet,
 				PoolVariableIF::VAR_READ);
 		status = rawSet.read();
 		if (status == RETURN_OK) {
-			size_t temp = 0;
+			uint32_t temp = 0;
 			status = variable.getEntryEndianSafe(ptrToCopy, &temp, size);
 			if (status != RETURN_OK) {
 				return RETURN_FAILED;
@@ -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) {
-	size_t serializedSize = wrapper->getSerializedSize();
+	uint32_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;
 	}
 
-	size_t storeElementSize = 0;
+	uint32_t storeElementSize = 0;
 
 	result = wrapper->serialize(&storeElement, &storeElementSize,
-			serializedSize, SerializeIF::Endianness::BIG);
+			serializedSize, true);
 
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		storage->deleteData(address);

datapool/DataPoolAdmin.h

@@ -1,16 +1,15 @@
 #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/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>
+#include <framework/datapool/DataPoolParameterWrapper.h>
+#include <framework/ipc/MessageQueueIF.h>
 
 class DataPoolAdmin: public HasActionsIF,
 		public ExecutableObjectIF,
@@ -30,12 +29,12 @@ public:
 	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,
+			uint32_t size, uint8_t** dataPointer);
+	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, size_t size);
+			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,

datapool/DataPoolParameterWrapper.cpp

@@ -1,8 +1,10 @@
-#include <framework/datapoolglob/GlobalDataSet.h>
-#include <framework/datapoolglob/DataPoolParameterWrapper.h>
-#include <framework/datapoolglob/PoolRawAccess.h>
+#include "DataPoolParameterWrapper.h"
+
+//for returncodes
 #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(
@@ -18,7 +20,7 @@ ReturnValue_t DataPoolParameterWrapper::set(uint8_t domainId,
 		uint16_t parameterId) {
 	poolId = (domainId << 16) + parameterId;
 
-	GlobDataSet mySet;
+	DataSet mySet;
 	PoolRawAccess raw(poolId, 0, &mySet, PoolVariableIF::VAR_READ);
 	ReturnValue_t status = mySet.read();
 	if (status != HasReturnvaluesIF::RETURN_OK) {
@@ -34,31 +36,31 @@ ReturnValue_t DataPoolParameterWrapper::set(uint8_t domainId,
 }
 
 ReturnValue_t DataPoolParameterWrapper::serialize(uint8_t** buffer,
-		size_t* size, size_t maxSize, Endianness streamEndianness) const {
+		uint32_t* size, const uint32_t max_size, bool bigEndian) const {
 	ReturnValue_t result;
 
-	result = SerializeAdapter::serialize(&type, buffer, size, maxSize,
-			streamEndianness);
+	result = SerializeAdapter<Type>::serialize(&type, buffer, size, max_size,
+			bigEndian);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}
 
-	result = SerializeAdapter::serialize(&columns, buffer, size,
-			maxSize, streamEndianness);
+	result = SerializeAdapter<uint8_t>::serialize(&columns, buffer, size,
+			max_size, bigEndian);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}
-	result = SerializeAdapter::serialize(&rows, buffer, size, maxSize,
-			streamEndianness);
+	result = SerializeAdapter<uint8_t>::serialize(&rows, buffer, size, max_size,
+			bigEndian);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}
 
 	for (uint8_t index = 0; index < rows; index++){
-		GlobDataSet mySet;
+		DataSet mySet;
 		PoolRawAccess raw(poolId, index, &mySet,PoolVariableIF::VAR_READ);
 		mySet.read();
-		result = raw.serialize(buffer,size,maxSize,streamEndianness);
+		result = raw.serialize(buffer,size,max_size,bigEndian);
 		if (result != HasReturnvaluesIF::RETURN_OK){
 			return result;
 		}
@@ -67,8 +69,8 @@ ReturnValue_t DataPoolParameterWrapper::serialize(uint8_t** buffer,
 }
 
 //same as ParameterWrapper
-size_t DataPoolParameterWrapper::getSerializedSize() const {
-	size_t serializedSize = 0;
+uint32_t DataPoolParameterWrapper::getSerializedSize() const {
+	uint32_t serializedSize = 0;
 	serializedSize += type.getSerializedSize();
 	serializedSize += sizeof(rows);
 	serializedSize += sizeof(columns);
@@ -78,7 +80,7 @@ size_t DataPoolParameterWrapper::getSerializedSize() const {
 }
 
 ReturnValue_t DataPoolParameterWrapper::deSerialize(const uint8_t** buffer,
-		size_t* size, Endianness streamEndianness) {
+		int32_t* size, bool bigEndian) {
 	return HasReturnvaluesIF::RETURN_FAILED;
 }
 
@@ -92,7 +94,7 @@ ReturnValue_t DataPoolParameterWrapper::deSerializeData(uint8_t startingRow,
 
 	for (uint8_t fromRow = 0; fromRow < fromRows; fromRow++) {
 
-		GlobDataSet mySet;
+		DataSet mySet;
 		PoolRawAccess raw(poolId, startingRow + fromRow, &mySet,
 				PoolVariableIF::VAR_READ_WRITE);
 		mySet.read();

datapool/DataPoolParameterWrapper.h

@@ -11,13 +11,13 @@ public:
 
 	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 ReturnValue_t serialize(uint8_t** buffer, uint32_t* size,
+			const uint32_t max_size, bool bigEndian) const;
 
-	virtual size_t getSerializedSize() const override;
+	virtual uint32_t getSerializedSize() const;
 
-	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);
 
 	ReturnValue_t copyFrom(const ParameterWrapper *from,
 			uint16_t startWritingAtIndex);

datapool/DataSet.cpp

@@ -0,0 +1,150 @@
+#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, uint32_t* size,
+		const uint32_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;
+}
+
+uint32_t DataSet::getSerializedSize() const {
+	uint32_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, int32_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;
+}

datapool/DataSet.h

@@ -0,0 +1,159 @@
+/*
+ * \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 {
+private:
+	//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 );
+	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);
+
+	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);
+
+};
+
+#endif /* DATASET_H_ */

datapool/DataSetBase.cpp

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

datapool/DataSetBase.h

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

datapool/DataSetIF.h

@@ -1,62 +1,39 @@
+/**
+ * \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>
-#include <framework/timemanager/Clock.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.
- * @author 	Bastian Baetz
- * @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.
+ *
+ *	\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.
+	 * \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.
+	 * \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;
+	virtual void registerVariable( PoolVariableIF* variable ) = 0;
 };
 
 #endif /* DATASETIF_H_ */

datapool/HkSwitchHelper.cpp

@@ -1,4 +1,5 @@
 #include <framework/datapool/HkSwitchHelper.h>
+//#include <mission/tmtcservices/HKService_03.h>
 #include <framework/ipc/QueueFactory.h>
 
 HkSwitchHelper::HkSwitchHelper(EventReportingProxyIF* eventProxy) :
@@ -21,14 +22,14 @@ ReturnValue_t HkSwitchHelper::initialize() {
 }
 
 ReturnValue_t HkSwitchHelper::performOperation(uint8_t operationCode) {
-	CommandMessage command;
-	while (actionQueue->receiveMessage(&command) == HasReturnvaluesIF::RETURN_OK) {
-		ReturnValue_t result = commandActionHelper.handleReply(&command);
+	CommandMessage message;
+	while (actionQueue->receiveMessage(&message) == HasReturnvaluesIF::RETURN_OK) {
+		ReturnValue_t result = commandActionHelper.handleReply(&message);
 		if (result == HasReturnvaluesIF::RETURN_OK) {
 			continue;
 		}
-		command.setToUnknownCommand();
-		actionQueue->reply(&command);
+		message.setToUnknownCommand();
+		actionQueue->reply(&message);
 	}
 
 	return HasReturnvaluesIF::RETURN_OK;

datapool/PIDReader.h

@@ -1,7 +1,7 @@
 #ifndef PIDREADER_H_
 #define PIDREADER_H_
+#include <framework/datapool/DataPool.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>
@@ -15,10 +15,10 @@ class PIDReader: public PoolVariableIF {
 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);
+	ReturnValue_t read() {
+		uint8_t arrayIndex = DataPool::PIDToArrayIndex(parameterId);
+		PoolEntry<T>* read_out = ::dataPool.getData<T>(
+				DataPool::PIDToDataPoolId(parameterId), arrayIndex);
 		if (read_out != NULL) {
 			valid = read_out->valid;
 			value = read_out->address[arrayIndex];
@@ -36,19 +36,14 @@ 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(uint32_t lockTimeout) override {
+	ReturnValue_t commit() {
 		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) {
+		parameterId(PoolVariableIF::NO_PARAMETER), valid(PoolVariableIF::INVALID), value(0) {
 
 	}
 public:
@@ -68,31 +63,18 @@ 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);
 		}
 	}
 
-	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) :
+	PIDReader(const PIDReader& rhs) :
 			parameterId(rhs.parameterId), valid(rhs.valid), value(rhs.value) {
 	}
 
@@ -106,7 +88,7 @@ public:
 	 * \brief	This operation returns the data pool id of the variable.
 	 */
 	uint32_t getDataPoolId() const {
-		return GlobalDataPool::PIDToDataPoolId(parameterId);
+		return DataPool::PIDToDataPoolId(parameterId);
 	}
 	uint32_t getParameterId() const {
 		return parameterId;
@@ -131,7 +113,7 @@ public:
 		return valid;
 	}
 
-	void setValid(bool valid) {
+	void setValid(uint8_t valid) {
 		this->valid = valid;
 	}
 
@@ -139,25 +121,24 @@ public:
 		return value;
 	}
 
-	PIDReader<T>& operator=(T newValue) {
+	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 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 size_t getSerializedSize() const override {
-		return SerializeAdapter::getSerializedSize(&value);
+	virtual uint32_t getSerializedSize() const {
+		return SerializeAdapter<T>::getSerializedSize(&value);
 	}
 
-	virtual ReturnValue_t deSerialize(const uint8_t **buffer, size_t *size,
-			Endianness streamEndianness) override {
-		return SerializeAdapter::deSerialize(&value, buffer, size,
-				streamEndianness);
+	virtual ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size,
+	bool bigEndian) {
+		return SerializeAdapter<T>::deSerialize(&value, buffer, size, bigEndian);
 	}
 };
 

datapool/PIDReaderList.h

@@ -1,8 +1,8 @@
-#ifndef FRAMEWORK_DATAPOOLGLOB_PIDREADERLIST_H_
-#define FRAMEWORK_DATAPOOLGLOB_PIDREADERLIST_H_
+#ifndef FRAMEWORK_DATAPOOL_PIDREADERLIST_H_
+#define FRAMEWORK_DATAPOOL_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_DATAPOOLGLOB_PIDREADERLIST_H_ */
+#endif /* FRAMEWORK_DATAPOOL_PIDREADERLIST_H_ */

datapool/PoolEntry.cpp

@@ -1,34 +1,13 @@
 #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) {
+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.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() );
+	if (initValue != NULL) {
+		memcpy(this->address, initValue, this->getByteSize() );
 	} else {
-		std::memset(this->address, 0, this->getByteSize() );
+		memset(this->address, 0, this->getByteSize() );
 	}
 }
 
@@ -55,20 +34,21 @@ void* PoolEntry<T>::getRawData() {
 }
 
 template <typename T>
-void PoolEntry<T>::setValid(bool isValid) {
+void PoolEntry<T>::setValid( uint8_t isValid ) {
 	this->valid = isValid;
 }
 
 template <typename T>
-bool PoolEntry<T>::getValid() {
+uint8_t 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);
+	for (uint8_t size = 0; size < this->length; size++ ) {
+		sif::debug << "| " << std::hex << (double)this->address[size]
+		           << (this->valid? " (valid) " : " (invalid) ");
+	}
 	sif::debug << std::dec << std::endl;
 }
 

datapool/PoolEntry.h

@@ -1,126 +1,81 @@
-#ifndef FRAMEWORK_DATAPOOL_POOLENTRY_H_
-#define FRAMEWORK_DATAPOOL_POOLENTRY_H_
+#ifndef POOLENTRY_H_
+#define POOLENTRY_H_
+
 
 #include <framework/datapool/PoolEntryIF.h>
-
-#include <initializer_list>
-#include <type_traits>
-#include <cstddef>
-
+#include <stddef.h>
+#include <cstring>
 /**
- * @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.
+ * \brief		This is a small helper class that defines a single data pool entry.
  *
- * 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.
+ * \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.
  *
- * 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
  *
- * @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
+	 * \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.
+	 * \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(std::initializer_list<T> initValue = {}, uint8_t setLength = 1,
-			bool setValid = false);
+	PoolEntry( T* initValue = NULL, 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 (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.
+	 * \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( bool isValid );
+	void setValid( uint8_t 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.
 	 */
-	bool getValid();
+	uint8_t 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();
 

datapool/PoolEntryIF.h

@@ -1,57 +1,62 @@
-#ifndef FRAMEWORK_DATAPOOL_POOLENTRYIF_H_
-#define FRAMEWORK_DATAPOOL_POOLENTRYIF_H_
+/**
+ * \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 <cstdint>
+#include <stdint.h>
+
+
 
 /**
- * @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.
+ * \brief	This interface defines the access possibilities to a single data pool entry.
  *
- * @author	Bastian Baetz
- * @ingroup data_pool
+ * \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
  *
  */
 class PoolEntryIF {
 public:
 	/**
-	 * @brief	This is an empty virtual destructor,
-	 * 			as it is required for C++ interfaces.
+	 * \brief	This is an empty virtual destructor, as it is proposed for C++ interfaces.
 	 */
 	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(bool isValid) = 0;
+	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 bool getValid() = 0;
+	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.
-	 * @details
-	 * Also displays whether the pool entry is valid or invalid.
+	 * \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;
 	/**

datapool/PoolRawAccess.cpp

@@ -0,0 +1,199 @@
+#include <framework/datapool/DataPool.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) {
+	memset(value, 0, sizeof(value));
+	if (data_set != NULL) {
+		data_set->registerVariable(this);
+	}
+}
+
+PoolRawAccess::~PoolRawAccess() {
+
+}
+
+ReturnValue_t PoolRawAccess::read() {
+	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 {
+				//Error value type too large.
+			}
+		} else {
+			//Error index requested too large
+		}
+	} else {
+		//Error entry does not exist.
+	}
+	sif::error << "PoolRawAccess: read of DP Variable 0x" << std::hex << dataPoolId
+			<< std::dec << " failed." << std::endl;
+	valid = INVALID;
+	typeSize = 0;
+	sizeTillEnd = 0;
+	memset(value, 0, sizeof(value));
+	return HasReturnvaluesIF::RETURN_FAILED;
+}
+
+ReturnValue_t PoolRawAccess::commit() {
+	PoolEntryIF* write_back = ::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,
+		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;
+	if (typeSize == 0)
+		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
+	*writtenBytes = typeSize;
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+Type PoolRawAccess::getType() {
+	return type;
+}
+
+uint8_t PoolRawAccess::getSizeOfType() {
+	return typeSize;
+}
+
+uint8_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,
+		uint32_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
+		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(uint8_t valid) {
+	this->valid = valid;
+}
+
+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;
+}
+
+ReturnValue_t PoolRawAccess::deSerialize(const uint8_t** buffer, int32_t* size,
+		bool bigEndian) {
+	*size -= typeSize;
+	if (*size >= 0) {
+
+		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++) {
+				value[count] = (*buffer)[typeSize - count - 1];
+			}
+#elif BYTE_ORDER_SYSTEM == BIG_ENDIAN
+			memcpy(value, *buffer, typeSize);
+#endif
+		} else {
+			memcpy(value, *buffer, typeSize);
+		}
+		*buffer += typeSize;
+		return HasReturnvaluesIF::RETURN_OK;
+	} else {
+		return SerializeIF::STREAM_TOO_SHORT;
+	}
+}

datapool/PoolRawAccess.h

@@ -0,0 +1,152 @@
+#ifndef POOLRAWACCESS_H_
+#define POOLRAWACCESS_H_
+
+#include <framework/datapool/DataSetIF.h>
+#include <framework/datapool/PoolVariableIF.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
+ */
+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);
+	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, 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);
+};
+
+#endif /* POOLRAWACCESS_H_ */

datapool/PoolRawAccessHelper.cpp

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

datapool/PoolRawAccessHelper.h

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

datapool/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:
-	GlobPoolVar<T> variables[n_var];
+	PoolVariable<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:
 		}
 	}
 
-	GlobPoolVar<T> &operator [](int i) { return variables[i]; }
+	PoolVariable<T> &operator [](int i) { return variables[i]; }
 };
 
 

datapool/PoolVariable.h

@@ -0,0 +1,295 @@
+/*
+ * \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 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,
+			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, uint32_t* size,
+			const uint32_t max_size, bool bigEndian) const {
+		return SerializeAdapter<T>::serialize(&value, buffer, size, max_size,
+				bigEndian);
+	}
+
+	virtual uint32_t getSerializedSize() const {
+		return SerializeAdapter<T>::getSerializedSize(&value);
+	}
+
+	virtual ReturnValue_t deSerialize(const uint8_t** buffer, int32_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_ */

datapool/PoolVariableIF.h

@@ -1,99 +1,71 @@
-#ifndef FRAMEWORK_DATAPOOL_POOLVARIABLEIF_H_
-#define FRAMEWORK_DATAPOOL_POOLVARIABLEIF_H_
+/*
+ * \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 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
+ * \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
  */
 class PoolVariableIF : public SerializeIF {
-	friend class DataSetBase;
-	friend class GlobDataSet;
-	friend class LocalDataSet;
+	friend class DataSet;
+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 = 0xffffffff;
-
+	static const uint8_t VALID = 1;
+	static const uint8_t INVALID = 0;
+	static const 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.
 	 */
-	virtual void setValid(bool validity) = 0;
+	virtual void setValid(uint8_t 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_ */

datapool/PoolVector.h

@@ -0,0 +1,233 @@
+/*
+ * \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, uint32_t* size,
+			const uint32_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 uint32_t getSerializedSize() const {
+		return vector_size * SerializeAdapter<T>::getSerializedSize(value);
+	}
+
+	virtual ReturnValue_t deSerialize(const uint8_t** buffer, int32_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_ */

datapoolglob/GlobalDataPool.cpp

@@ -1,132 +0,0 @@
-#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(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);

datapoolglob/GlobalDataPool.h

@@ -1,149 +0,0 @@
-#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_ */

datapoolglob/GlobalDataSet.cpp

@@ -1,44 +0,0 @@
-#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;
-}
-
-

datapoolglob/GlobalDataSet.h

@@ -1,96 +0,0 @@
-#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_ */

datapoolglob/GlobalPoolVariable.h

@@ -1,213 +0,0 @@
-#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_ */

datapoolglob/GlobalPoolVariable.tpp

@@ -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

datapoolglob/GlobalPoolVector.h

@@ -1,185 +0,0 @@
-#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_ */

datapoolglob/GlobalPoolVector.tpp

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

datapoolglob/PoolRawAccess.cpp

@@ -1,239 +0,0 @@
-#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;
-    }
-}

datapoolglob/PoolRawAccess.h

@@ -1,220 +0,0 @@
-#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_ */

datapoollocal/HasLocalDataPoolIF.h

@@ -1,77 +0,0 @@
-#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_ */

datapoollocal/LocalDataPoolManager.cpp

@@ -1,218 +0,0 @@
-#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;
-}

datapoollocal/LocalDataPoolManager.h

@@ -1,229 +0,0 @@
-#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_ */

datapoollocal/LocalDataSet.cpp

@@ -1,106 +0,0 @@
-#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;
-}
-

datapoollocal/LocalDataSet.h

@@ -1,115 +0,0 @@
-#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_ */

datapoollocal/LocalPoolVariable.h

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

datapoollocal/LocalPoolVariable.tpp

@@ -1,159 +0,0 @@
-#ifndef FRAMEWORK_DATAPOOLLOCAL_LOCALPOOLVARIABLE_TPP_
-#define FRAMEWORK_DATAPOOLLOCAL_LOCALPOOLVARIABLE_TPP_
-
-#ifndef FRAMEWORK_DATAPOOLLOCAL_LOCALPOOLVARIABLE_H_
-#error Include LocalPoolVariable.h before LocalPoolVariable.tpp!
-#endif
-
-template<typename T>
-inline LocalPoolVar<T>::LocalPoolVar(lp_id_t poolId,
-		HasLocalDataPoolIF* 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);
-	}
-}
-
-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;
-	}
-	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);
-	}
-}
-
-template<typename T>
-inline ReturnValue_t LocalPoolVar<T>::read(dur_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;
-		return PoolVariableIF::INVALID_READ_WRITE_MODE;
-	}
-
-	PoolEntry<T>* poolEntry = nullptr;
-	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(dur_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;
-		return PoolVariableIF::INVALID_READ_WRITE_MODE;
-	}
-	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;
-	}
-	*(poolEntry->address) = this->value;
-	poolEntry->valid = this->valid;
-	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 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 {
-	return SerializeAdapter::serialize(&value,
-			buffer, size ,max_size, streamEndianness);
-}
-
-template<typename T>
-inline size_t LocalPoolVar<T>::getSerializedSize() const {
-	return SerializeAdapter::getSerializedSize(&value);
-}
-
-template<typename T>
-inline ReturnValue_t LocalPoolVar<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) {
-    out << var.value;
-    return out;
-}
-
-#endif

datapoollocal/LocalPoolVector.h

@@ -1,200 +0,0 @@
-#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_ */

datapoollocal/LocalPoolVector.tpp

@@ -1,206 +0,0 @@
-#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,
-		HasLocalDataPoolIF* 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));
-	hkManager = hkOwner->getHkManagerHandle();
-	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;
-	}
-	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);
-	}
-}
-
-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;
-	}
-	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];
-	}
-	// 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>
-inline const T& LocalPoolVector<T, vectorSize>::operator [](int 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.
-	sif::error << "LocalPoolVector: Invalid index. Setting or returning"
-			" last value!" << std::endl;
-	return value[i];
-}
-
-template<typename T, uint16_t vectorSize>
-inline ReturnValue_t LocalPoolVector<T, vectorSize>::serialize(uint8_t** buffer,
-		size_t* size, size_t maxSize,
-		SerializeIF::Endianness streamEndianness) const {
-	ReturnValue_t result = HasReturnvaluesIF::RETURN_FAILED;
-	for (uint16_t i = 0; i < vectorSize; i++) {
-		result = SerializeAdapter::serialize(&(value[i]), buffer, size,
-				maxSize, streamEndianness);
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			break;
-		}
-	}
-	return result;
-}
-
-template<typename T, uint16_t vectorSize>
-inline size_t LocalPoolVector<T, vectorSize>::getSerializedSize() const {
-	return vectorSize * SerializeAdapter::getSerializedSize(value);
-}
-
-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;
-}
-
-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) {
-    out << "Vector: [";
-    for(int i = 0;i < vectorSize; i++) {
-        out << var.value[i];
-        if(i < vectorSize - 1) {
-            out << ", ";
-        }
-    }
-    out << "]";
-    return out;
-}
-
-#endif

datapoollocal/StaticLocalDataSet.cpp

@@ -1,6 +0,0 @@
-#include <framework/datapoollocal/StaticLocalDataSet.h>
-
-
-
-
-

datapoollocal/StaticLocalDataSet.h

@@ -1,11 +0,0 @@
-#ifndef FRAMEWORK_DATAPOOLLOCAL_STATICLOCALDATASET_H_
-#define FRAMEWORK_DATAPOOLLOCAL_STATICLOCALDATASET_H_
-#include <framework/datapool/DataSetBase.h>
-
-
-class StaticLocalDataSet: public DataSetBase {
-
-};
-
-
-#endif /* FRAMEWORK_DATAPOOLLOCAL_STATICLOCALDATASET_H_ */

devicehandlers/AcceptsDeviceResponsesIF.h

@@ -1,19 +1,23 @@
-#ifndef FRAMEWORK_DEVICEHANDLERS_ACCEPTSDEVICERESPONSESIF_H_
-#define FRAMEWORK_DEVICEHANDLERS_ACCEPTSDEVICERESPONSESIF_H_
+/**
+ * @file	AcceptsDeviceResponsesIF.h
+ * @brief	This file defines the AcceptsDeviceResponsesIF class.
+ * @date	15.05.2013
+ * @author	baetz
+ */
+
+#ifndef ACCEPTSDEVICERESPONSESIF_H_
+#define 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;
+	virtual ~AcceptsDeviceResponsesIF() {
+}
+virtual MessageQueueId_t getDeviceQueue() = 0;
 };
 
-#endif /* FRAMEWORK_DEVICEHANDLERS_ACCEPTSDEVICERESPONSESIF_H_ */
+#endif /* ACCEPTSDEVICERESPONSESIF_H_ */

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);
 }
 

devicehandlers/ChildHandlerBase.cpp

@@ -2,20 +2,15 @@
 #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(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, uint32_t cmdQueueSize) :
+		DeviceHandlerBase(ioBoardAddress, setObjectId, maxDeviceReplyLen,
+				setDeviceSwitch, deviceCommunication, thermalStatePoolId,
+				thermalRequestPoolId, (customFdir == NULL? &childHandlerFdir : customFdir), cmdQueueSize), parentId(
+				parent), childHandlerFdir(setObjectId) {
 }
 
 ChildHandlerBase::~ChildHandlerBase() {
@@ -29,7 +24,7 @@ ReturnValue_t ChildHandlerBase::initialize() {
 
 	MessageQueueId_t parentQueue = 0;
 
-	if (parentId != objects::NO_OBJECT) {
+	if (parentId != 0) {
 		SubsystemBase *parent = objectManager->get<SubsystemBase>(parentId);
 		if (parent == NULL) {
 			return RETURN_FAILED;
@@ -39,7 +34,7 @@ ReturnValue_t ChildHandlerBase::initialize() {
 		parent->registerChild(getObjectId());
 	}
 
-	healthHelper.setParentQueue(parentQueue);
+	healthHelper.setParentQeueue(parentQueue);
 
 	modeHelper.setParentQueue(parentQueue);
 

devicehandlers/ChildHandlerBase.h

@@ -6,11 +6,12 @@
 
 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);
+	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);
 	virtual ~ChildHandlerBase();
 
 	virtual ReturnValue_t initialize();

devicehandlers/CommunicationMessage.cpp

@@ -1,201 +0,0 @@
-/**
- * @file CommunicationMessage.cpp
- *
- * @date 28.02.2020
- */
-
-#include <framework/devicehandlers/CommunicationMessage.h>
-#include <framework/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;
-	}
-}
-

devicehandlers/CommunicationMessage.h

@@ -1,173 +0,0 @@
-/**
- * @file CommunicationMessage.h
- *
- * @date 28.02.2020
- */
-
-#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>
-#include <framework/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_ */

devicehandlers/Cookie.h

@@ -0,0 +1,10 @@
+#ifndef COOKIE_H_
+#define COOKIE_H_
+
+class Cookie{
+public:
+	virtual ~Cookie(){}
+};
+
+
+#endif /* COOKIE_H_ */

devicehandlers/CookieIF.h

@@ -1,33 +0,0 @@
-#ifndef COOKIE_H_
-#define COOKIE_H_
-#include <cstdint>
-
-/**
- * @brief Physical address type
- */
-typedef std::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 @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.
- *
- * 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_ */

devicehandlers/DeviceCommunicationIF.h

@@ -1,127 +1,63 @@
-#ifndef FRAMEWORK_DEVICES_DEVICECOMMUNICATIONIF_H_
-#define FRAMEWORK_DEVICES_DEVICECOMMUNICATIONIF_H_
+#ifndef DEVICECOMMUNICATIONIF_H_
+#define DEVICECOMMUNICATIONIF_H_
 
-#include <framework/devicehandlers/CookieIF.h>
-#include <framework/devicehandlers/DeviceHandlerIF.h>
+#include <framework/devicehandlers/Cookie.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);
+	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);
 
-	//! 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() {
 
-	virtual ~DeviceCommunicationIF() {}
+	}
+
+	virtual ReturnValue_t open(Cookie **cookie, uint32_t address,
+			uint32_t maxReplyLen) = 0;
 
 	/**
-	 * @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).
+	 * 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 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
+	 * @param address
+	 * @param maxReplyLen
+	 * @return
 	 */
-	virtual ReturnValue_t requestReceiveMessage(CookieIF *cookie,
-	        size_t requestLen) = 0;
+	virtual ReturnValue_t reOpen(Cookie *cookie, uint32_t address,
+			uint32_t maxReplyLen) = 0;
+
+	virtual void close(Cookie *cookie) = 0;
+
+	//SHOULDDO can data be const?
+	virtual ReturnValue_t sendMessage(Cookie *cookie, uint8_t *data,
+			uint32_t len) = 0;
+
+	virtual ReturnValue_t getSendSuccess(Cookie *cookie) = 0;
+
+	virtual ReturnValue_t requestReceiveMessage(Cookie *cookie) = 0;
+
+	virtual ReturnValue_t readReceivedMessage(Cookie *cookie, uint8_t **buffer,
+			uint32_t *size) = 0;
+
+	virtual ReturnValue_t setAddress(Cookie *cookie, uint32_t address) = 0;
+
+	virtual uint32_t getAddress(Cookie *cookie) = 0;
+
+	virtual ReturnValue_t setParameter(Cookie *cookie, uint32_t parameter) = 0;
+
+	virtual uint32_t getParameter(Cookie *cookie) = 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_ */

devicehandlers/DeviceHandlerFailureIsolation.cpp

@@ -7,15 +7,13 @@
 
 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() {
@@ -70,11 +68,9 @@ ReturnValue_t DeviceHandlerFailureIsolation::eventReceived(EventMessage* event)
 		break;
 		//****Power*****
 	case PowerSwitchIF::SWITCH_WENT_OFF:
-		if(hasPowerConfirmation) {
-			result = sendConfirmationRequest(event, powerConfirmation);
-			if (result == RETURN_OK) {
-				setFdirState(DEVICE_MIGHT_BE_OFF);
-			}
+		result = sendConfirmationRequest(event, powerConfirmation);
+		if (result == RETURN_OK) {
+			setFdirState(DEVICE_MIGHT_BE_OFF);
 		}
 		break;
 	case Fuse::FUSE_WENT_OFF:
@@ -137,7 +133,7 @@ void DeviceHandlerFailureIsolation::decrementFaultCounters() {
 
 void DeviceHandlerFailureIsolation::handleRecovery(Event reason) {
 	clearFaultCounters();
-	if (not recoveryCounter.incrementAndCheck()) {
+	if (!recoveryCounter.incrementAndCheck()) {
 		startRecovery(reason);
 	} else {
 		setFaulty(reason);
@@ -146,8 +142,7 @@ 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)) {
@@ -163,17 +158,14 @@ 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>(
 			powerConfirmationId);
-	if (power != nullptr) {
-		powerConfirmation = power->getEventReceptionQueue();
-		hasPowerConfirmation = true;
+	if (power == NULL) {
+		return RETURN_FAILED;
 	}
-
+	powerConfirmation = power->getEventReceptionQueue();
 	return RETURN_OK;
 }
 

devicehandlers/DeviceHandlerFailureIsolation.h

@@ -28,10 +28,8 @@ protected:
 		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;

devicehandlers/DeviceHandlerIF.h

@@ -8,8 +8,7 @@
 #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.
+ * This is the Interface used to communicate with a device handler.
  *
  */
 class DeviceHandlerIF {
@@ -23,129 +22,93 @@ 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
 	 */
+//		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;
+		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.
-	//! 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 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;
+		//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 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  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 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.
-	};
+		//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.
+		};
 	/**
 	 * 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;

devicehandlers/DeviceHandlerMessage.cpp

@@ -47,7 +47,7 @@ void DeviceHandlerMessage::setDeviceHandlerWiretappingMessage(
 
 void DeviceHandlerMessage::setDeviceHandlerSwitchIoBoardMessage(
 		CommandMessage* message, uint32_t ioBoardIdentifier) {
-	message->setCommand(CMD_SWITCH_ADDRESS);
+	message->setCommand(CMD_SWITCH_IOBOARD);
 	message->setParameter(ioBoardIdentifier);
 }
 
@@ -90,7 +90,7 @@ void DeviceHandlerMessage::clear(CommandMessage* message) {
 		}
 	}
 		/* NO BREAK falls through*/
-	case CMD_SWITCH_ADDRESS:
+	case CMD_SWITCH_IOBOARD:
 	case CMD_WIRETAPPING:
 		message->setCommand(CommandMessage::CMD_NONE);
 		message->setParameter(0);

devicehandlers/DeviceHandlerMessage.h

@@ -25,10 +25,10 @@ public:
 	/**
 	 * These are the commands that can be sent to a DeviceHandlerBase
 	 */
-	static const uint8_t MESSAGE_ID = messagetypes::DEVICE_HANDLER_COMMAND;
+	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_ADDRESS = MAKE_COMMAND_ID( 3 ); //!< Requests a IO-Board switch, setParameter() is the IO-Board identifier
+	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_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)

devicehandlers/DeviceTmReportingWrapper.cpp

@@ -12,35 +12,35 @@ 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);
+		uint32_t* size, const uint32_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) {
 		return result;
 	}
-	result = SerializeAdapter::serialize(&actionId, buffer,
-			size, maxSize, streamEndianness);
+	result = SerializeAdapter<ActionId_t>::serialize(&actionId, buffer,
+			size, max_size, bigEndian);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}
-	return data->serialize(buffer, size, maxSize, streamEndianness);
+	return data->serialize(buffer, size, max_size, bigEndian);
 }
 
-size_t DeviceTmReportingWrapper::getSerializedSize() const {
+uint32_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);
+		int32_t* size, bool bigEndian) {
+	ReturnValue_t result = SerializeAdapter<object_id_t>::deSerialize(&objectId,
+			buffer, size, bigEndian);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}
-	result = SerializeAdapter::deSerialize(&actionId, buffer,
-			size, streamEndianness);
+	result = SerializeAdapter<ActionId_t>::deSerialize(&actionId, buffer,
+			size, bigEndian);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}
-	return data->deSerialize(buffer, size, streamEndianness);
+	return data->deSerialize(buffer, size, bigEndian);
 }

devicehandlers/DeviceTmReportingWrapper.h

@@ -11,13 +11,13 @@ public:
 			SerializeIF *data);
 	virtual ~DeviceTmReportingWrapper();
 
-	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
-			size_t maxSize, Endianness streamEndianness) const override;
+	virtual ReturnValue_t serialize(uint8_t** buffer, uint32_t* size,
+			const uint32_t max_size, bool bigEndian) const;
 
-	virtual size_t getSerializedSize() const override;
+	virtual uint32_t getSerializedSize() const;
 
-	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);
 private:
 	object_id_t objectId;
 	ActionId_t actionId;

devicehandlers/FixedSequenceSlot.cpp

@@ -0,0 +1,21 @@
+/**
+ * @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 <cstddef>
+
+FixedSequenceSlot::FixedSequenceSlot(object_id_t handlerId, uint32_t setTime,
+		int8_t setSequenceId, PeriodicTaskIF* executingTask) :
+		handler(NULL), pollingTimeMs(setTime), opcode(setSequenceId) {
+	handler = objectManager->get<ExecutableObjectIF>(handlerId);
+	handler->setTaskIF(executingTask);
+}
+
+FixedSequenceSlot::~FixedSequenceSlot() {
+}
+

devicehandlers/FixedSequenceSlot.h

@@ -0,0 +1,48 @@
+/**
+ * @file	FixedSequenceSlot.h
+ * @brief	This file defines the PollingSlot class.
+ * @date	19.12.2012
+ * @author	baetz
+ */
+
+#ifndef FIXEDSEQUENCESLOT_H_
+#define 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.
+ */
+class FixedSequenceSlot {
+public:
+			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.
+	 */
+	ExecutableObjectIF*	handler;
+
+	/**
+	 * \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
+	 * 			from a database.
+	 */
+	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;
+};
+
+
+#endif /* FIXEDSEQUENCESLOT_H_ */

devicehandlers/FixedSlotSequence.cpp

@@ -1,6 +1,5 @@
+#include <framework/devicehandlers/FixedSlotSequence.h>
 #include <framework/serviceinterface/ServiceInterfaceStream.h>
-#include <framework/tasks/FixedSlotSequence.h>
-#include <cstdlib>
 
 FixedSlotSequence::FixedSlotSequence(uint32_t setLengthMs) :
 		lengthMs(setLengthMs) {
@@ -8,12 +7,17 @@ FixedSlotSequence::FixedSlotSequence(uint32_t setLengthMs) :
 }
 
 FixedSlotSequence::~FixedSlotSequence() {
-	// Call the destructor on each list entry.
-	slotList.clear();
+	std::list<FixedSequenceSlot*>::iterator slotIt;
+	//Iterate through slotList and delete all entries.
+	slotIt = this->slotList.begin();
+	while (slotIt != this->slotList.end()) {
+		delete (*slotIt);
+		slotIt++;
+	}
 }
 
 void FixedSlotSequence::executeAndAdvance() {
-	current->handler->performOperation(current->opcode);
+	(*this->current)->handler->performOperation((*this->current)->opcode);
 //	if (returnValue != RETURN_OK) {
 //		this->sendErrorMessage( returnValue );
 //	}
@@ -27,50 +31,53 @@ void FixedSlotSequence::executeAndAdvance() {
 
 uint32_t FixedSlotSequence::getIntervalToNextSlotMs() {
 	uint32_t oldTime;
-	SlotListIter slotListIter = current;
+	std::list<FixedSequenceSlot*>::iterator it;
+	it = current;
 	// Get the pollingTimeMs of the current slot object.
-	oldTime = slotListIter->pollingTimeMs;
+	oldTime = (*it)->pollingTimeMs;
 	// Advance to the next object.
-	slotListIter++;
+	it++;
 	// Find the next interval which is not 0.
-	while (slotListIter != slotList.end()) {
-		if (oldTime != slotListIter->pollingTimeMs) {
-			return slotListIter->pollingTimeMs - oldTime;
+	while (it != slotList.end()) {
+		if (oldTime != (*it)->pollingTimeMs) {
+			return (*it)->pollingTimeMs - oldTime;
 		} else {
-			slotListIter++;
+			it++;
 		}
 	}
 	// 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;
+	it = slotList.begin();
+	return lengthMs - oldTime + (*it)->pollingTimeMs;
 }
 
 uint32_t FixedSlotSequence::getIntervalToPreviousSlotMs() {
 	uint32_t currentTime;
-	SlotListIter slotListIter = current;
+	std::list<FixedSequenceSlot*>::iterator it;
+	it = current;
 	// Get the pollingTimeMs of the current slot object.
-	currentTime = slotListIter->pollingTimeMs;
+	currentTime = (*it)->pollingTimeMs;
 
 	//if it is the first slot, calculate difference to last slot
-	if (slotListIter == slotList.begin()){
-		return lengthMs - (--slotList.end())->pollingTimeMs + currentTime;
+	if (it == slotList.begin()){
+		return lengthMs - (*(--slotList.end()))->pollingTimeMs + currentTime;
 	}
 	// get previous slot
-	slotListIter--;
+	it--;
 
-	return currentTime - slotListIter->pollingTimeMs;
+	return currentTime - (*it)->pollingTimeMs;
 }
 
 bool FixedSlotSequence::slotFollowsImmediately() {
-	uint32_t currentTime = current->pollingTimeMs;
-	SlotListIter fixedSequenceIter = this->current;
+	uint32_t currentTime = (*current)->pollingTimeMs;
+	std::list<FixedSequenceSlot*>::iterator it;
+	it = this->current;
 	// Get the pollingTimeMs of the current slot object.
-	if (fixedSequenceIter == slotList.begin())
+	if (it == slotList.begin())
 		return false;
-	fixedSequenceIter--;
-	if (fixedSequenceIter->pollingTimeMs == currentTime) {
+	it--;
+	if ((*it)->pollingTimeMs == currentTime) {
 		return true;
 	} else {
 		return false;
@@ -86,30 +93,26 @@ ReturnValue_t FixedSlotSequence::checkSequence() const {
 		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) {
+		if ((*slotIt)->handler == NULL) {
 			sif::error << "FixedSlotSequene::initialize: ObjectId does not exist!"
 					<< std::endl;
 			count++;
-		} else if (slotIt->pollingTimeMs < time) {
+		} else if ((*slotIt)->pollingTimeMs < time) {
 			sif::error << "FixedSlotSequence::initialize: Time: "
-					<< slotIt->pollingTimeMs
+					<< (*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;
+			//All ok, print slot.
+//			(*slotIt)->print();
 		}
-		time = slotIt->pollingTimeMs;
+		time = (*slotIt)->pollingTimeMs;
 		slotIt++;
 	}
-	//info << "Number of elements in slot list: "
-	//	   << slotList.size() << std::endl;
 	if (count > 0) {
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}
@@ -118,7 +121,8 @@ 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->slotList.push_back(
+			new FixedSequenceSlot(componentId, slotTimeMs, executionStep,
+					executingTask));
 	this->current = slotList.begin();
 }

devicehandlers/FixedSlotSequence.h

@@ -0,0 +1,128 @@
+#ifndef FIXEDSLOTSEQUENCE_H_
+#define FIXEDSLOTSEQUENCE_H_
+
+#include <framework/devicehandlers/FixedSequenceSlot.h>
+#include <framework/objectmanager/SystemObject.h>
+#include <list>
+
+/**
+ * @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:
+
+	/**
+	 * \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.
+	 */
+	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 prevous 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 OPUSPollingSlot 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.
+	 */
+	std::list<FixedSequenceSlot*>::iterator 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 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.
+	 * 			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.
+	 */
+	std::list<FixedSequenceSlot*> slotList;
+
+	uint32_t lengthMs;
+};
+
+#endif /* FIXEDSLOTSEQUENCE_H_ */

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::MINIMUM_COMMAND_MESSAGE_SIZE);
+	commandQueue = QueueFactory::instance()->createMessageQueue(3, CommandMessage::COMMAND_MESSAGE_SIZE);
 }
 
 HealthDevice::~HealthDevice() {
@@ -13,10 +13,10 @@ HealthDevice::~HealthDevice() {
 }
 
 ReturnValue_t HealthDevice::performOperation(uint8_t opCode) {
-	CommandMessage command;
-	ReturnValue_t result = commandQueue->receiveMessage(&command);
+	CommandMessage message;
+	ReturnValue_t result = commandQueue->receiveMessage(&message);
 	if (result == HasReturnvaluesIF::RETURN_OK) {
-		healthHelper.handleHealthCommand(&command);
+		healthHelper.handleHealthCommand(&message);
 	}
 	return HasReturnvaluesIF::RETURN_OK;
 }
@@ -38,7 +38,7 @@ MessageQueueId_t HealthDevice::getCommandQueue() const {
 }
 
 void HealthDevice::setParentQueue(MessageQueueId_t parentQueue) {
-	healthHelper.setParentQueue(parentQueue);
+	healthHelper.setParentQeueue(parentQueue);
 }
 
 bool HealthDevice::hasHealthChanged() {

events/Event.h

@@ -1,10 +1,10 @@
-#ifndef FRAMEWORK_EVENTS_EVENT_H_
-#define FRAMEWORK_EVENTS_EVENT_H_
+#ifndef EVENTOBJECT_EVENT_H_
+#define EVENTOBJECT_EVENT_H_
 
-#include <cstdint>
+#include <stdint.h>
 #include <framework/events/fwSubsystemIdRanges.h>
 //could be move to more suitable location
-#include <subsystemIdRanges.h>
+#include <config/tmtc/subsystemIdRanges.h>
 
 typedef uint16_t EventId_t;
 typedef uint8_t EventSeverity_t;
@@ -21,7 +21,6 @@ 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;
@@ -42,4 +41,4 @@ namespace SEVERITY {
 //	static const EventSeverity_t HIGH = 4;
 //};
 
-#endif /* FRAMEWORK_EVENTS_EVENT_H_ */
+#endif /* EVENTOBJECT_EVENT_H_ */

events/EventManager.cpp

@@ -8,16 +8,13 @@
 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?
+//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),
-		factoryBackend(0, POOL_SIZES, N_ELEMENTS, false, true) {
+		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);
@@ -52,7 +49,7 @@ 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());
+					message->getSender());
 		}
 	}
 	unlockMutex();
@@ -133,23 +130,16 @@ void EventManager::printEvent(EventMessage* message) {
 		break;
 	default:
 		string = translateObject(message->getReporter());
-		sif::debug << "EventManager: ";
+		sif::error << "EVENT: ";
 		if (string != 0) {
-			sif::debug << string;
+			sif::error << string;
+		} else {
+			sif::error << "0x" << std::hex << message->getReporter() << std::dec;
 		}
-		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;
+		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;
 	}
 
@@ -157,7 +147,7 @@ void EventManager::printEvent(EventMessage* message) {
 #endif
 
 void EventManager::lockMutex() {
-	mutex->lockMutex(MutexIF::BLOCKING);
+	mutex->lockMutex(MutexIF::NO_TIMEOUT);
 }
 
 void EventManager::unlockMutex() {

events/EventManager.h

@@ -36,11 +36,11 @@ public:
 	ReturnValue_t performOperation(uint8_t opCode);
 protected:
 
-	MessageQueueIF* eventReportQueue = nullptr;
+	MessageQueueIF* eventReportQueue;
 
 	std::map<MessageQueueId_t, EventMatchTree> listenerList;
 
-	MutexIF* mutex = nullptr;
+	MutexIF* mutex;
 
 	static const uint8_t N_POOLS = 3;
 	LocalPool<N_POOLS> factoryBackend;

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, size_t* size,
-			size_t maxSize, Endianness streamEndianness) const {
-		return rangeMatcher.serialize(buffer, size, maxSize, streamEndianness);
+	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);
 	}
-	size_t getSerializedSize() const {
+	uint32_t getSerializedSize() const {
 		return rangeMatcher.getSerializedSize();
 	}
-	ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
-			Endianness streamEndianness) {
-		return rangeMatcher.deSerialize(buffer, size, streamEndianness);
+	ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size,
+			bool bigEndian) {
+		return rangeMatcher.deSerialize(buffer, size, bigEndian);
 	}
 protected:
 	RangeMatcher<T> rangeMatcher;

events/fwSubsystemIdRanges.h

@@ -18,7 +18,6 @@ enum {
 	SYSTEM_MANAGER = 74,
 	SYSTEM_MANAGER_1 = 75,
 	SYSTEM_1 = 79,
-	PUS_SERVICE_1 = 80
 };
 }