Merge branch 'mueller_framework' into front_branch

action/ActionHelper.cpp

@@ -85,7 +85,7 @@ ReturnValue_t ActionHelper::reportData(MessageQueueId_t reportTo,
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}
-	result = data->serialize(&dataPtr, &size, maxSize, true);
+	result = data->serialize(&dataPtr, &size, maxSize, SerializeIF::Endianness::BIG);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		ipcStore->deleteData(storeAddress);
 		return result;

action/CommandActionHelper.cpp

@@ -27,7 +27,8 @@ ReturnValue_t CommandActionHelper::commandAction(object_id_t commandTo,
 		return result;
 	}
 	size_t size = 0;
-	result = data->serialize(&storePointer, &size, maxSize, true);
+	result = data->serialize(&storePointer, &size, maxSize,
+			SerializeIF::Endianness::BIG);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}
@@ -88,7 +89,8 @@ ReturnValue_t CommandActionHelper::handleReply(CommandMessage* reply) {
 		return HasReturnvaluesIF::RETURN_OK;
 	case ActionMessage::COMPLETION_FAILED:
 		commandCount--;
-		owner->completionFailedReceived(ActionMessage::getActionId(reply), ActionMessage::getReturnCode(reply));
+		owner->completionFailedReceived(ActionMessage::getActionId(reply),
+				ActionMessage::getReturnCode(reply));
 		return HasReturnvaluesIF::RETURN_OK;
 	case ActionMessage::STEP_SUCCESS:
 		owner->stepSuccessfulReceived(ActionMessage::getActionId(reply),
@@ -96,11 +98,13 @@ ReturnValue_t CommandActionHelper::handleReply(CommandMessage* reply) {
 		return HasReturnvaluesIF::RETURN_OK;
 	case ActionMessage::STEP_FAILED:
 		commandCount--;
-		owner->stepFailedReceived(ActionMessage::getActionId(reply), ActionMessage::getStep(reply),
+		owner->stepFailedReceived(ActionMessage::getActionId(reply),
+				ActionMessage::getStep(reply),
 				ActionMessage::getReturnCode(reply));
 		return HasReturnvaluesIF::RETURN_OK;
 	case ActionMessage::DATA_REPLY:
-		extractDataForOwner(ActionMessage::getActionId(reply), ActionMessage::getStoreId(reply));
+		extractDataForOwner(ActionMessage::getActionId(reply),
+				ActionMessage::getStoreId(reply));
 		return HasReturnvaluesIF::RETURN_OK;
 	default:
 		return HasReturnvaluesIF::RETURN_FAILED;

container/FIFO.h

@@ -1,82 +1,31 @@
-#ifndef FIFO_H_
+#ifndef FRAMEWORK_CONTAINER_FIFO_H_
-#define FIFO_H_
+#define FRAMEWORK_CONTAINER_FIFO_H_
 
-#include <framework/returnvalues/HasReturnvaluesIF.h>
+#include <framework/container/FIFOBase.h>
+#include <vector>
+
+namespace fsfw {
 
 /**
- * @brief Simple First-In-First-Out data structure
+ * @brief 	Simple First-In-First-Out data structure. The maximum size
+ * 			can be set in the constructor.
+ * @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, uint8_t capacity>
+template<typename T>
-class FIFO {
+class FIFO: public FIFOBase<T> {
-private:
-	uint8_t readIndex, writeIndex, currentSize;
-	T data[capacity];
-
-	uint8_t next(uint8_t current) {
-		++current;
-		if (current == capacity) {
-			current = 0;
-		}
-		return current;
-	}
 public:
-	FIFO() :
+	FIFO(size_t maxCapacity): FIFOBase<T>(values.data(), maxCapacity),
-			readIndex(0), writeIndex(0), currentSize(0) {
+			values(maxCapacity) {};
-	}
 
-	bool empty() {
+private:
-		return (currentSize == 0);
+	std::vector<T> values;
-	}
-
-	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 /* FIFO_H_ */
+}
+
+#endif /* FRAMEWORK_CONTAINER_FIFO_H_ */

container/FIFOBase.h

@@ -0,0 +1,65 @@
+#ifndef FRAMEWORK_CONTAINER_FIFOBASE_H_
+#define FRAMEWORK_CONTAINER_FIFOBASE_H_
+
+#include <framework/returnvalues/HasReturnvaluesIF.h>
+#include <cstddef>
+
+namespace fsfw {
+
+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;
+
+private:
+	T* values;
+	size_t maxCapacity = 0;
+
+	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

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

container/FixedMap.h

@@ -164,6 +164,7 @@ public:
 		return theMap.maxSize();
 	}
 
+
 	bool full() {
 		if(_size == theMap.maxSize()) {
 			return true;
@@ -174,15 +175,15 @@ public:
 	}
 
 	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
-			const size_t max_size, bool bigEndian) const {
+			size_t maxSize, Endianness streamEndianness) const {
-		ReturnValue_t result = SerializeAdapter<uint32_t>::serialize(&this->_size,
+		ReturnValue_t result = SerializeAdapter::serialize(&this->_size,
-				buffer, size, max_size, bigEndian);
+				buffer, size, maxSize, streamEndianness);
 		uint32_t i = 0;
 		while ((result == HasReturnvaluesIF::RETURN_OK) && (i < this->_size)) {
-			result = SerializeAdapter<key_t>::serialize(&theMap[i].first, buffer,
+			result = SerializeAdapter::serialize(&theMap[i].first, buffer,
-					size, max_size, bigEndian);
+					size, maxSize, streamEndianness);
-			result = SerializeAdapter<T>::serialize(&theMap[i].second, buffer, size,
+			result = SerializeAdapter::serialize(&theMap[i].second, buffer, size,
-					max_size, bigEndian);
+					maxSize, streamEndianness);
 			++i;
 		}
 		return result;
@@ -193,27 +194,27 @@ public:
 		uint32_t i = 0;
 
 		for (i = 0; i < _size; ++i) {
-			printSize += SerializeAdapter<key_t>::getSerializedSize(
+			printSize += SerializeAdapter::getSerializedSize(
 					&theMap[i].first);
-			printSize += SerializeAdapter<T>::getSerializedSize(&theMap[i].second);
+			printSize += SerializeAdapter::getSerializedSize(&theMap[i].second);
 		}
 
 		return printSize;
 	}
 
 	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
-			bool bigEndian) {
+			Endianness streamEndianness) {
-		ReturnValue_t result = SerializeAdapter<uint32_t>::deSerialize(&this->_size,
+		ReturnValue_t result = SerializeAdapter::deSerialize(&this->_size,
-				buffer, size, bigEndian);
+				buffer, size, streamEndianness);
 		if (this->_size > theMap.maxSize()) {
 			return SerializeIF::TOO_MANY_ELEMENTS;
 		}
 		uint32_t i = 0;
 		while ((result == HasReturnvaluesIF::RETURN_OK) && (i < this->_size)) {
-			result = SerializeAdapter<key_t>::deSerialize(&theMap[i].first, buffer,
+			result = SerializeAdapter::deSerialize(&theMap[i].first, buffer,
-					size, bigEndian);
+					size, streamEndianness);
-			result = SerializeAdapter<T>::deSerialize(&theMap[i].second, buffer, size,
+			result = SerializeAdapter::deSerialize(&theMap[i].second, buffer, size,
-					bigEndian);
+					streamEndianness);
 			++i;
 		}
 		return result;

container/IndexedRingMemoryArray.h

@@ -75,50 +75,50 @@ public:
 		return this->storedPackets;
 	}
 
-	ReturnValue_t serialize(uint8_t** buffer, uint32_t* size,
+	ReturnValue_t serialize(uint8_t** buffer, size_t* size,
-				const uint32_t max_size, bool bigEndian) const {
+				size_t maxSize, Endianness streamEndianness) const {
-		ReturnValue_t result = AutoSerializeAdapter::serialize(&blockStartAddress,buffer,size,max_size,bigEndian);
+		ReturnValue_t result = SerializeAdapter::serialize(&blockStartAddress,buffer,size,maxSize,streamEndianness);
 		if(result != HasReturnvaluesIF::RETURN_OK){
 			return result;
 		}
-		result = indexType.serialize(buffer,size,max_size,bigEndian);
+		result = indexType.serialize(buffer,size,maxSize,streamEndianness);
 		if(result != HasReturnvaluesIF::RETURN_OK){
 			return result;
 		}
-		result = AutoSerializeAdapter::serialize(&this->size,buffer,size,max_size,bigEndian);
+		result = SerializeAdapter::serialize(&this->size,buffer,size,maxSize,streamEndianness);
 		if(result != HasReturnvaluesIF::RETURN_OK){
 			return result;
 		}
-		result = AutoSerializeAdapter::serialize(&this->storedPackets,buffer,size,max_size,bigEndian);
+		result = SerializeAdapter::serialize(&this->storedPackets,buffer,size,maxSize,streamEndianness);
 		return result;
 	}
 
-	ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size,
+	ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
-				bool bigEndian){
+				Endianness streamEndianness){
-		ReturnValue_t result = AutoSerializeAdapter::deSerialize(&blockStartAddress,buffer,size,bigEndian);
+		ReturnValue_t result = SerializeAdapter::deSerialize(&blockStartAddress,buffer,size,streamEndianness);
 		if(result != HasReturnvaluesIF::RETURN_OK){
 			return result;
 		}
-		result = indexType.deSerialize(buffer,size,bigEndian);
+		result = indexType.deSerialize(buffer,size,streamEndianness);
 		if(result != HasReturnvaluesIF::RETURN_OK){
 			return result;
 		}
-		result = AutoSerializeAdapter::deSerialize(&this->size,buffer,size,bigEndian);
+		result = SerializeAdapter::deSerialize(&this->size,buffer,size,streamEndianness);
 		if(result != HasReturnvaluesIF::RETURN_OK){
 			return result;
 		}
-		result = AutoSerializeAdapter::deSerialize(&this->storedPackets,buffer,size,bigEndian);
+		result = SerializeAdapter::deSerialize(&this->storedPackets,buffer,size,streamEndianness);
 		if(result != HasReturnvaluesIF::RETURN_OK){
 			return result;
 		}
 		return result;
 	}
 
-	uint32_t getSerializedSize() const {
+	size_t getSerializedSize() const {
-		uint32_t size = AutoSerializeAdapter::getSerializedSize(&blockStartAddress);
+		uint32_t size = SerializeAdapter::getSerializedSize(&blockStartAddress);
 		size += indexType.getSerializedSize();
-		size += AutoSerializeAdapter::getSerializedSize(&this->size);
+		size += SerializeAdapter::getSerializedSize(&this->size);
-		size += AutoSerializeAdapter::getSerializedSize(&this->storedPackets);
+		size += SerializeAdapter::getSerializedSize(&this->storedPackets);
 		return size;
 	}
 
@@ -509,37 +509,37 @@ public:
 	 * Parameters according to HasSerializeIF
 	 * @param buffer
 	 * @param size
-	 * @param max_size
+	 * @param maxSize
-	 * @param bigEndian
+	 * @param streamEndianness
 	 * @return
 	 */
-	ReturnValue_t serialize(uint8_t** buffer, uint32_t* size,
+	ReturnValue_t serialize(uint8_t** buffer, size_t* size,
-				const uint32_t max_size, bool bigEndian) const{
+				size_t maxSize, Endianness streamEndianness) const{
 		uint8_t* crcBuffer = *buffer;
 		uint32_t oldSize = *size;
 		if(additionalInfo!=NULL){
-			additionalInfo->serialize(buffer,size,max_size,bigEndian);
+			additionalInfo->serialize(buffer,size,maxSize,streamEndianness);
 		}
-		ReturnValue_t result = currentWriteBlock->serialize(buffer,size,max_size,bigEndian);
+		ReturnValue_t result = currentWriteBlock->serialize(buffer,size,maxSize,streamEndianness);
 		if(result != HasReturnvaluesIF::RETURN_OK){
 					return result;
 		}
-		result = AutoSerializeAdapter::serialize(&this->size,buffer,size,max_size,bigEndian);
+		result = SerializeAdapter::serialize(&this->size,buffer,size,maxSize,streamEndianness);
 		if(result != HasReturnvaluesIF::RETURN_OK){
 					return result;
 		}
 
 		uint32_t i = 0;
 		while ((result == HasReturnvaluesIF::RETURN_OK) && (i < this->size)) {
-			result = SerializeAdapter<Index<T> >::serialize(&this->entries[i], buffer, size,
+			result = SerializeAdapter::serialize(&this->entries[i], buffer, size,
-					max_size, bigEndian);
+					maxSize, streamEndianness);
 			++i;
 		}
 		if(result != HasReturnvaluesIF::RETURN_OK){
 			return result;
 		}
 		uint16_t crc = Calculate_CRC(crcBuffer,(*size-oldSize));
-		result = AutoSerializeAdapter::serialize(&crc,buffer,size,max_size,bigEndian);
+		result = SerializeAdapter::serialize(&crc,buffer,size,maxSize,streamEndianness);
 		return result;
 	}
 
@@ -555,10 +555,10 @@ public:
 			size += additionalInfo->getSerializedSize();
 		}
 		size += currentWriteBlock->getSerializedSize();
-		size += AutoSerializeAdapter::getSerializedSize(&this->size);
+		size += SerializeAdapter::getSerializedSize(&this->size);
 		size += (this->entries[0].getSerializedSize()) * this->size;
 		uint16_t crc = 0;
-		size += AutoSerializeAdapter::getSerializedSize(&crc);
+		size += SerializeAdapter::getSerializedSize(&crc);
 		return size;
 	}
 	/**
@@ -566,28 +566,28 @@ public:
 	 * CRC Has to be checked before!
 	 * @param buffer
 	 * @param size
-	 * @param bigEndian
+	 * @param streamEndianness
 	 * @return
 	 */
 
-	ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size,
+	ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
-				bool bigEndian){
+				Endianness streamEndianness){
 
 		ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
 		if(additionalInfo!=NULL){
-			result = additionalInfo->deSerialize(buffer,size,bigEndian);
+			result = additionalInfo->deSerialize(buffer,size,streamEndianness);
 		}
 		if(result != HasReturnvaluesIF::RETURN_OK){
 					return result;
 		}
 
 		Index<T> tempIndex;
-		result = tempIndex.deSerialize(buffer,size,bigEndian);
+		result = tempIndex.deSerialize(buffer,size,streamEndianness);
 		if(result != HasReturnvaluesIF::RETURN_OK){
 					return result;
 		}
 		uint32_t tempSize = 0;
-		result = AutoSerializeAdapter::deSerialize(&tempSize,buffer,size,bigEndian);
+		result = SerializeAdapter::deSerialize(&tempSize,buffer,size,streamEndianness);
 		if(result != HasReturnvaluesIF::RETURN_OK){
 					return result;
 		}
@@ -596,9 +596,9 @@ public:
 		}
 		uint32_t i = 0;
 		while ((result == HasReturnvaluesIF::RETURN_OK) && (i < this->size)) {
-			result = SerializeAdapter<Index<T> >::deSerialize(
+			result = SerializeAdapter::deSerialize(
 					&this->entries[i], buffer, size,
-					bigEndian);
+					streamEndianness);
 			++i;
 		}
 		if(result != HasReturnvaluesIF::RETURN_OK){

container/StaticFIFO.h

@@ -0,0 +1,30 @@
+#ifndef FRAMEWORK_CONTAINER_STATICFIFO_H_
+#define FRAMEWORK_CONTAINER_STATICFIFO_H_
+
+#include <framework/returnvalues/HasReturnvaluesIF.h>
+#include <framework/container/FIFOBase.h>
+#include <array>
+
+namespace fsfw {
+
+/**
+ * @brief 	Simple First-In-First-Out data structure with size fixed at
+ * 			compile time
+ * @details
+ * Performs no dynamic memory allocation.
+ * The public interface of FIFOBase exposes the user interface for the FIFO.
+ * @tparam T Entry Type
+ * @tparam capacity Maximum capacity
+ */
+template<typename T, size_t capacity>
+class StaticFIFO: public FIFOBase<T> {
+public:
+	StaticFIFO(): FIFOBase<T>(values.data(), capacity) {};
+
+private:
+	std::array<T, capacity> values;
+};
+
+}
+
+#endif /* FRAMEWORK_CONTAINERS_STATICFIFO_H_ */

datapool/DataSetBase.cpp

@@ -1,8 +1,11 @@
 #include <framework/datapool/DataSetBase.h>
 #include <framework/serviceinterface/ServiceInterfaceStream.h>
 
-DataSetBase::DataSetBase() {
+DataSetBase::DataSetBase(PoolVariableIF** registeredVariablesArray,
-	for (uint8_t count = 0; count < DATA_SET_MAX_SIZE; count++) {
+        const size_t maxFillCount):
+        registeredVariables(registeredVariablesArray),
+        maxFillCount(maxFillCount) {
+	for (uint8_t count = 0; count < maxFillCount; count++) {
 		registeredVariables[count] = nullptr;
 	}
 }
@@ -21,7 +24,7 @@ ReturnValue_t DataSetBase::registerVariable(
 				"Pool variable is nullptr." << std::endl;
 		return DataSetIF::POOL_VAR_NULL;
 	}
-	if (fillCount >= DATA_SET_MAX_SIZE) {
+	if (fillCount >= maxFillCount) {
 		sif::error << "DataSet::registerVariable: "
 				"DataSet is full." << std::endl;
 		return DataSetIF::DATA_SET_FULL;
@@ -131,11 +134,11 @@ ReturnValue_t DataSetBase::unlockDataPool() {
 }
 
 ReturnValue_t DataSetBase::serialize(uint8_t** buffer, size_t* size,
-		const size_t maxSize, bool bigEndian) const {
+		const size_t maxSize, SerializeIF::Endianness streamEndianness) const {
 	ReturnValue_t result = HasReturnvaluesIF::RETURN_FAILED;
 	for (uint16_t count = 0; count < fillCount; count++) {
 		result = registeredVariables[count]->serialize(buffer, size, maxSize,
-				bigEndian);
+		        streamEndianness);
 		if (result != HasReturnvaluesIF::RETURN_OK) {
 			return result;
 		}
@@ -144,11 +147,11 @@ ReturnValue_t DataSetBase::serialize(uint8_t** buffer, size_t* size,
 }
 
 ReturnValue_t DataSetBase::deSerialize(const uint8_t** buffer, size_t* size,
-		bool bigEndian) {
+        SerializeIF::Endianness streamEndianness) {
 	ReturnValue_t result = HasReturnvaluesIF::RETURN_FAILED;
 	for (uint16_t count = 0; count < fillCount; count++) {
 		result = registeredVariables[count]->deSerialize(buffer, size,
-				bigEndian);
+				streamEndianness);
 		if (result != HasReturnvaluesIF::RETURN_OK) {
 			return result;
 		}

datapool/DataSetBase.h

@@ -37,7 +37,8 @@ public:
 	 * 			supply a pointer to this dataset to PoolVariable
 	 * 			initializations to register pool variables.
 	 */
-	DataSetBase();
+	DataSetBase(PoolVariableIF** registeredVariablesArray,
+	        const size_t maxFillCount);
 	virtual~ DataSetBase();
 
 	/**
@@ -105,15 +106,11 @@ public:
 
 	/* SerializeIF implementations */
 	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
-				const size_t maxSize, bool bigEndian) const override;
+				const size_t maxSize,
+				SerializeIF::Endianness streamEndianness) const override;
 	virtual size_t getSerializedSize() const override;
 	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
-			bool bigEndian) override;
+	        SerializeIF::Endianness streamEndianness) override;
-
-	// SHOULDDO we could use a linked list of datapool variables
-	//!< This definition sets the maximum number of variables to
-	//! register in one DataSet.
-	static const uint8_t DATA_SET_MAX_SIZE = 63;
 
 protected:
 	/**
@@ -137,8 +134,11 @@ protected:
 
 	/**
 	 * @brief	This array represents all pool variables registered in this set.
+	 * Child classes can use a static or dynamic container to create
+	 * an array of registered variables and assign the first entry here.
 	 */
-	PoolVariableIF* registeredVariables[DATA_SET_MAX_SIZE] = { };
+	PoolVariableIF** registeredVariables = nullptr;
+	const size_t maxFillCount = 0;
 
 private:
 	ReturnValue_t readVariable(uint16_t count);

datapool/PoolRawAccessHelper.cpp

@@ -24,8 +24,9 @@ PoolRawAccessHelper::~PoolRawAccessHelper() {
 }
 
 ReturnValue_t PoolRawAccessHelper::serialize(uint8_t **buffer, size_t *size,
-		const size_t max_size, bool bigEndian) {
+		const size_t max_size, SerializeIF::Endianness streamEndianness) {
-	SerializationArgs serializationArgs = {buffer, size, max_size, bigEndian};
+	SerializationArgs serializationArgs = {buffer, size, max_size,
+	        streamEndianness};
 	ReturnValue_t result = RETURN_OK;
 	size_t remainingParametersSize = numberOfParameters * 4;
 	for(uint8_t count=0; count < numberOfParameters; count++) {
@@ -44,9 +45,10 @@ ReturnValue_t PoolRawAccessHelper::serialize(uint8_t **buffer, size_t *size,
 }
 
 ReturnValue_t PoolRawAccessHelper::serializeWithValidityMask(uint8_t ** buffer,
-		size_t * size, const size_t max_size, bool bigEndian) {
+		size_t * size, const size_t max_size,
+		SerializeIF::Endianness streamEndianness) {
 	ReturnValue_t result = RETURN_OK;
-	SerializationArgs argStruct = {buffer, size, max_size, bigEndian};
+	SerializationArgs argStruct = {buffer, size, max_size, streamEndianness};
 	size_t remainingParametersSize = numberOfParameters * 4;
 	uint8_t validityMaskSize = ceil((float)numberOfParameters/8.0);
 	uint8_t validityMask[validityMaskSize];
@@ -76,8 +78,8 @@ ReturnValue_t PoolRawAccessHelper::serializeCurrentPoolEntryIntoBuffer(
 		bool withValidMask, uint8_t * validityMask) {
 	uint32_t currentPoolId;
 	// Deserialize current pool ID from pool ID buffer
-	ReturnValue_t result = AutoSerializeAdapter::deSerialize(&currentPoolId,
+	ReturnValue_t result = SerializeAdapter::deSerialize(&currentPoolId,
-			&poolIdBuffer,remainingParameters, false);
+			&poolIdBuffer,remainingParameters, SerializeIF::Endianness::MACHINE);
 	if(result != RETURN_OK) {
 		sif::debug << std::hex << "PoolRawAccessHelper: Error deSeralizing "
 				"pool IDs" << std::dec << std::endl;
@@ -137,7 +139,7 @@ ReturnValue_t PoolRawAccessHelper::handlePoolEntrySerialization(
 		}
 
 		result = currentDataSet.serialize(argStruct.buffer, argStruct.size,
-				argStruct.max_size, argStruct.bigEndian);
+				argStruct.max_size, argStruct.streamEndianness);
 		if (result != RETURN_OK) {
 			sif::debug << "Pool Raw Access Helper: Error serializing pool data with "
 					 "ID 0x" << std::hex << currentPoolId << " into send buffer "

datapool/PoolRawAccessHelper.h

@@ -43,7 +43,7 @@ public:
 	 * 			@c RETURN_FAILED on failure
 	 */
 	ReturnValue_t serialize(uint8_t ** buffer, size_t * size,
-			const size_t max_size, bool bigEndian);
+			const size_t max_size, SerializeIF::Endianness streamEndianness);
 
 	/**
 	 * Serializes data pool entries into provided buffer with the validity mask buffer
@@ -56,7 +56,7 @@ public:
 	 * 			@c RETURN_FAILED on failure
 	 */
 	ReturnValue_t serializeWithValidityMask(uint8_t ** buffer, size_t * size,
-			const size_t max_size, bool bigEndian);
+			const size_t max_size, SerializeIF::Endianness streamEndianness);
 
 
 private:
@@ -71,7 +71,7 @@ private:
 		uint8_t ** buffer;
 		size_t * size;
 		const size_t max_size;
-		bool bigEndian;
+		SerializeIF::Endianness streamEndianness;
 	};
 	/**
 	 * Helper function to serialize single pool entries

datapoolglob/DataPoolAdmin.cpp

@@ -26,7 +26,7 @@ MessageQueueId_t DataPoolAdmin::getCommandQueue() const {
 }
 
 ReturnValue_t DataPoolAdmin::executeAction(ActionId_t actionId,
-		MessageQueueId_t commandedBy, const uint8_t* data, uint32_t size) {
+		MessageQueueId_t commandedBy, const uint8_t* data, size_t size) {
 	if (actionId != SET_VALIDITY) {
 		return INVALID_ACTION_ID;
 	}
@@ -91,7 +91,7 @@ void DataPoolAdmin::handleCommand() {
 }
 
 ReturnValue_t DataPoolAdmin::handleMemoryLoad(uint32_t address,
-		const uint8_t* data, uint32_t size, uint8_t** dataPointer) {
+		const uint8_t* data, size_t size, uint8_t** dataPointer) {
 	uint32_t poolId = glob::dataPool.PIDToDataPoolId(address);
 	uint8_t arrayIndex = glob::dataPool.PIDToArrayIndex(address);
 	GlobDataSet testSet;
@@ -129,7 +129,7 @@ ReturnValue_t DataPoolAdmin::handleMemoryLoad(uint32_t address,
 	return ACTIVITY_COMPLETED;
 }
 
-ReturnValue_t DataPoolAdmin::handleMemoryDump(uint32_t address, uint32_t size,
+ReturnValue_t DataPoolAdmin::handleMemoryDump(uint32_t address, size_t size,
 		uint8_t** dataPointer, uint8_t* copyHere) {
 	uint32_t poolId = glob::dataPool.PIDToDataPoolId(address);
 	uint8_t arrayIndex = glob::dataPool.PIDToArrayIndex(address);
@@ -151,7 +151,7 @@ ReturnValue_t DataPoolAdmin::handleMemoryDump(uint32_t address, uint32_t size,
 				PoolVariableIF::VAR_READ);
 		status = rawSet.read();
 		if (status == RETURN_OK) {
-			uint32_t temp = 0;
+			size_t temp = 0;
 			status = variable.getEntryEndianSafe(ptrToCopy, &temp, size);
 			if (status != RETURN_OK) {
 				return RETURN_FAILED;
@@ -261,7 +261,7 @@ ReturnValue_t DataPoolAdmin::handleParameterCommand(CommandMessage* command) {
 //identical to ParameterHelper::sendParameter()
 ReturnValue_t DataPoolAdmin::sendParameter(MessageQueueId_t to, uint32_t id,
 		const DataPoolParameterWrapper* wrapper) {
-	uint32_t serializedSize = wrapper->getSerializedSize();
+	size_t serializedSize = wrapper->getSerializedSize();
 
 	uint8_t *storeElement;
 	store_address_t address;
@@ -275,7 +275,7 @@ ReturnValue_t DataPoolAdmin::sendParameter(MessageQueueId_t to, uint32_t id,
 	size_t storeElementSize = 0;
 
 	result = wrapper->serialize(&storeElement, &storeElementSize,
-			serializedSize, true);
+			serializedSize, SerializeIF::Endianness::BIG);
 
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		storage->deleteData(address);

datapoolglob/DataPoolAdmin.h

@@ -30,12 +30,12 @@ public:
 	MessageQueueId_t getCommandQueue() const;
 
 	ReturnValue_t handleMemoryLoad(uint32_t address, const uint8_t* data,
-			uint32_t size, uint8_t** dataPointer);
+			size_t size, uint8_t** dataPointer);
-	ReturnValue_t handleMemoryDump(uint32_t address, uint32_t size,
+	ReturnValue_t handleMemoryDump(uint32_t address, size_t size,
 			uint8_t** dataPointer, uint8_t* copyHere);
 
 	ReturnValue_t executeAction(ActionId_t actionId,
-			MessageQueueId_t commandedBy, const uint8_t* data, uint32_t size);
+			MessageQueueId_t commandedBy, const uint8_t* data, size_t size);
 
 	//not implemented as ParameterHelper is no used
 	ReturnValue_t getParameter(uint8_t domainId, uint16_t parameterId,

datapoolglob/DataPoolParameterWrapper.cpp

@@ -34,22 +34,22 @@ ReturnValue_t DataPoolParameterWrapper::set(uint8_t domainId,
 }
 
 ReturnValue_t DataPoolParameterWrapper::serialize(uint8_t** buffer,
-		size_t* size, const size_t max_size, bool bigEndian) const {
+		size_t* size, size_t maxSize, Endianness streamEndianness) const {
 	ReturnValue_t result;
 
-	result = SerializeAdapter<Type>::serialize(&type, buffer, size, max_size,
+	result = SerializeAdapter::serialize(&type, buffer, size, maxSize,
-			bigEndian);
+			streamEndianness);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}
 
-	result = SerializeAdapter<uint8_t>::serialize(&columns, buffer, size,
+	result = SerializeAdapter::serialize(&columns, buffer, size,
-			max_size, bigEndian);
+			maxSize, streamEndianness);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}
-	result = SerializeAdapter<uint8_t>::serialize(&rows, buffer, size, max_size,
+	result = SerializeAdapter::serialize(&rows, buffer, size, maxSize,
-			bigEndian);
+			streamEndianness);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}
@@ -58,7 +58,7 @@ ReturnValue_t DataPoolParameterWrapper::serialize(uint8_t** buffer,
 		GlobDataSet mySet;
 		PoolRawAccess raw(poolId, index, &mySet,PoolVariableIF::VAR_READ);
 		mySet.read();
-		result = raw.serialize(buffer,size,max_size,bigEndian);
+		result = raw.serialize(buffer,size,maxSize,streamEndianness);
 		if (result != HasReturnvaluesIF::RETURN_OK){
 			return result;
 		}
@@ -68,7 +68,7 @@ ReturnValue_t DataPoolParameterWrapper::serialize(uint8_t** buffer,
 
 //same as ParameterWrapper
 size_t DataPoolParameterWrapper::getSerializedSize() const {
-	uint32_t serializedSize = 0;
+	size_t serializedSize = 0;
 	serializedSize += type.getSerializedSize();
 	serializedSize += sizeof(rows);
 	serializedSize += sizeof(columns);
@@ -78,7 +78,7 @@ size_t DataPoolParameterWrapper::getSerializedSize() const {
 }
 
 ReturnValue_t DataPoolParameterWrapper::deSerialize(const uint8_t** buffer,
-		size_t* size, bool bigEndian) {
+		size_t* size, Endianness streamEndianness) {
 	return HasReturnvaluesIF::RETURN_FAILED;
 }
 

datapoolglob/DataPoolParameterWrapper.h

@@ -12,12 +12,12 @@ public:
 	ReturnValue_t set(uint8_t domainId, uint16_t parameterId);
 
 	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
-			const size_t max_size, bool bigEndian) const;
+			size_t maxSize, Endianness streamEndianness) const override;
 
-	virtual size_t getSerializedSize() const;
+	virtual size_t getSerializedSize() const override;
 
 	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
-			bool bigEndian);
+			Endianness streamEndianness) override;
 
 	ReturnValue_t copyFrom(const ParameterWrapper *from,
 			uint16_t startWritingAtIndex);

datapoolglob/GlobalDataSet.cpp

@@ -2,7 +2,9 @@
 #include <framework/datapoolglob/GlobalDataSet.h>
 #include <framework/serviceinterface/ServiceInterfaceStream.h>
 
-GlobDataSet::GlobDataSet(): DataSetBase() {}
+GlobDataSet::GlobDataSet(): DataSetBase(
+        reinterpret_cast<PoolVariableIF**>(&registeredVariables),
+        DATA_SET_MAX_SIZE) {}
 
 // Don't do anything with your variables, they are dead already!
 // (Destructor is already called)

datapoolglob/GlobalDataSet.h

@@ -61,6 +61,10 @@ public:
 	 */
 	void setEntriesValid(bool valid);
 
+	//!< This definition sets the maximum number of variables to
+	//! register in one DataSet.
+	static const uint8_t DATA_SET_MAX_SIZE = 63;
+
 private:
 	/**
 	 * If the valid state of a dataset is always relevant to the whole
@@ -85,6 +89,8 @@ private:
 
 	void handleAlreadyReadDatasetCommit();
 	ReturnValue_t handleUnreadDatasetCommit();
+
+	PoolVariableIF* registeredVariables[DATA_SET_MAX_SIZE];
 };
 
 #endif /* DATASET_H_ */

datapoolglob/GlobalPoolVariable.h

@@ -181,18 +181,20 @@ public:
 	}
 
 	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
-			const size_t max_size, bool bigEndian) const override {
+			const size_t max_size,
-		return SerializeAdapter<T>::serialize(&value, buffer, size, max_size,
+			SerializeIF::Endianness streamEndianness) const override {
-				bigEndian);
+		return SerializeAdapter::serialize(&value, buffer, size, max_size,
+				streamEndianness);
 	}
 
 	virtual size_t getSerializedSize() const {
-		return SerializeAdapter<T>::getSerializedSize(&value);
+		return SerializeAdapter::getSerializedSize(&value);
 	}
 
 	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
-			bool bigEndian) {
+	        SerializeIF::Endianness streamEndianness) {
-		return SerializeAdapter<T>::deSerialize(&value, buffer, size, bigEndian);
+		return SerializeAdapter::deSerialize(&value, buffer, size,
+		        streamEndianness);
 	}
 };
 

datapoolglob/GlobalPoolVector.h

@@ -109,10 +109,10 @@ public:
 	const T &operator [](int i) const {return value[i];}
 
 	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
-			const size_t max_size, bool bigEndian) const override;
+			size_t max_size, Endianness streamEndianness) const override;
 	virtual size_t getSerializedSize() const override;
 	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
-			bool bigEndian) override;
+	        Endianness streamEndianness) override;
 
 	/**
 	 * @brief	This is a call to read the array's values

datapoolglob/GlobalPoolVector.tpp

@@ -79,12 +79,13 @@ inline ReturnValue_t GlobPoolVector<T, vectorSize>::commitWithoutLock() {
 
 template<typename T, uint16_t vectorSize>
 inline ReturnValue_t GlobPoolVector<T, vectorSize>::serialize(uint8_t** buffer,
-		size_t* size, const size_t max_size, bool bigEndian) const {
+		size_t* size, size_t max_size,
+		SerializeIF::Endianness streamEndianness) const {
 	uint16_t i;
 	ReturnValue_t result;
 	for (i = 0; i < vectorSize; i++) {
-		result = SerializeAdapter<T>::serialize(&(value[i]), buffer, size,
+		result = SerializeAdapter::serialize(&(value[i]), buffer, size,
-				max_size, bigEndian);
+				max_size, streamEndianness);
 		if (result != HasReturnvaluesIF::RETURN_OK) {
 			return result;
 		}
@@ -94,17 +95,18 @@ inline ReturnValue_t GlobPoolVector<T, vectorSize>::serialize(uint8_t** buffer,
 
 template<typename T, uint16_t vectorSize>
 inline size_t GlobPoolVector<T, vectorSize>::getSerializedSize() const {
-	return vectorSize * SerializeAdapter<T>::getSerializedSize(value);
+	return vectorSize * SerializeAdapter::getSerializedSize(value);
 }
 
 template<typename T, uint16_t vectorSize>
 inline ReturnValue_t GlobPoolVector<T, vectorSize>::deSerialize(
-		const uint8_t** buffer, size_t* size, bool bigEndian) {
+		const uint8_t** buffer, size_t* size,
+		SerializeIF::Endianness streamEndianness) {
 	uint16_t i;
 	ReturnValue_t result;
 	for (i = 0; i < vectorSize; i++) {
-		result = SerializeAdapter<T>::deSerialize(&(value[i]), buffer, size,
+		result = SerializeAdapter::deSerialize(&(value[i]), buffer, size,
-				bigEndian);
+		        streamEndianness);
 		if (result != HasReturnvaluesIF::RETURN_OK) {
 			return result;
 		}

datapoolglob/PIDReader.h

@@ -15,7 +15,6 @@ 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>(
@@ -48,7 +47,8 @@ protected:
 	 * Empty ctor for List initialization
 	 */
 	PIDReader() :
-		parameterId(PoolVariableIF::NO_PARAMETER), valid(PoolVariableIF::INVALID), value(0) {
+			parameterId(PoolVariableIF::NO_PARAMETER), valid(
+					PoolVariableIF::INVALID), value(0) {
 
 	}
 public:
@@ -69,8 +69,8 @@ public:
 	 * 					written back to the data pool, otherwise not.
 	 */
 	PIDReader(uint32_t setParameterId, DataSetIF *dataSet) :
-			parameterId(setParameterId), valid(
+			parameterId(setParameterId), valid(PoolVariableIF::INVALID), value(
-					PoolVariableIF::INVALID), value(0) {
+					0) {
 		if (dataSet != NULL) {
 			dataSet->registerVariable(this);
 		}
@@ -145,18 +145,19 @@ public:
 	}
 
 	virtual ReturnValue_t serialize(uint8_t **buffer, size_t *size,
-			const size_t max_size, bool bigEndian) const {
+			size_t maxSize, Endianness streamEndianness) const override {
-		return SerializeAdapter<T>::serialize(&value, buffer, size, max_size,
+		return SerializeAdapter::serialize(&value, buffer, size, maxSize,
-				bigEndian);
+				streamEndianness);
 	}
 
-	virtual size_t getSerializedSize() const {
+	virtual size_t getSerializedSize() const override {
-		return SerializeAdapter<T>::getSerializedSize(&value);
+		return SerializeAdapter::getSerializedSize(&value);
 	}
 
 	virtual ReturnValue_t deSerialize(const uint8_t **buffer, size_t *size,
-	bool bigEndian) {
+			Endianness streamEndianness) override {
-		return SerializeAdapter<T>::deSerialize(&value, buffer, size, bigEndian);
+		return SerializeAdapter::deSerialize(&value, buffer, size,
+				streamEndianness);
 	}
 };
 

datapoolglob/PoolRawAccess.cpp

@@ -1,7 +1,7 @@
 #include <framework/datapoolglob/GlobalDataPool.h>
 #include <framework/datapoolglob/PoolRawAccess.h>
 #include <framework/serviceinterface/ServiceInterfaceStream.h>
-#include <framework/osal/Endiness.h>
+#include <framework/serialize/EndianConverter.h>
 
 #include <cstring>
 
@@ -121,7 +121,7 @@ uint8_t* PoolRawAccess::getEntry() {
 }
 
 ReturnValue_t PoolRawAccess::getEntryEndianSafe(uint8_t* buffer,
-		uint32_t* writtenBytes, uint32_t max_size) {
+		size_t* writtenBytes, size_t max_size) {
 	uint8_t* data_ptr = getEntry();
 	// debug << "PoolRawAccess::getEntry: Array position: " <<
 	// 	      index * size_of_type << " Size of T: " << (int)size_of_type <<
@@ -130,35 +130,26 @@ ReturnValue_t PoolRawAccess::getEntryEndianSafe(uint8_t* buffer,
 		return DATA_POOL_ACCESS_FAILED;
 	if (typeSize > max_size)
 		return INCORRECT_SIZE;
-#ifndef BYTE_ORDER_SYSTEM
+	EndianConverter::convertBigEndian(buffer, data_ptr, typeSize);
-#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;
 }
 
 
 ReturnValue_t PoolRawAccess::serialize(uint8_t** buffer, size_t* size,
-		const size_t max_size, bool bigEndian) const {
+        size_t maxSize, Endianness streamEndianness) const {
-	if (typeSize + *size <= max_size) {
+    if (typeSize + *size <= maxSize) {
-		if (bigEndian) {
+    	switch(streamEndianness) {
-#ifndef BYTE_ORDER_SYSTEM
+    	case(Endianness::BIG):
-#error BYTE_ORDER_SYSTEM not defined
+    		EndianConverter::convertBigEndian(*buffer, value, typeSize);
-#elif BYTE_ORDER_SYSTEM == LITTLE_ENDIAN
+    		break;
-			for (uint8_t count = 0; count < typeSize; count++) {
+    	case(Endianness::LITTLE):
-				(*buffer)[count] = value[typeSize - count - 1];
+			EndianConverter::convertLittleEndian(*buffer, value, typeSize);
-			}
+    		break;
-#elif BYTE_ORDER_SYSTEM == BIG_ENDIAN
+    	case(Endianness::MACHINE):
-			memcpy(*buffer, value, typeSize);
+    	default:
-#endif
-		} else {
             memcpy(*buffer, value, typeSize);
+            break;
         }
         *size += typeSize;
         (*buffer) += typeSize;
@@ -173,11 +164,11 @@ Type PoolRawAccess::getType() {
 	return type;
 }
 
-uint8_t PoolRawAccess::getSizeOfType() {
+size_t PoolRawAccess::getSizeOfType() {
 	return typeSize;
 }
 
-uint8_t PoolRawAccess::getArraySize(){
+size_t PoolRawAccess::getArraySize(){
 	return arraySize;
 }
 
@@ -190,21 +181,13 @@ PoolVariableIF::ReadWriteMode_t PoolRawAccess::getReadWriteMode() const {
 }
 
 ReturnValue_t PoolRawAccess::setEntryFromBigEndian(const uint8_t *buffer,
-		uint32_t setSize) {
+		size_t setSize) {
 	if (typeSize == setSize) {
-#ifndef BYTE_ORDER_SYSTEM
+		EndianConverter::convertBigEndian(value, buffer, typeSize);
-#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"
+		sif::error << "PoolRawAccess::setEntryFromBigEndian: Illegal sizes: "
-				<< (uint32_t) typeSize << ", Requested: " << setSize
+				"Internal" << (uint32_t) typeSize << ", Requested: " << setSize
 				<< std::endl;
 		return INCORRECT_SIZE;
 	}
@@ -221,7 +204,7 @@ void PoolRawAccess::setValid(bool valid) {
 	this->valid = valid;
 }
 
-uint16_t PoolRawAccess::getSizeTillEnd() const {
+size_t PoolRawAccess::getSizeTillEnd() const {
 	return sizeTillEnd;
 }
 
@@ -231,24 +214,22 @@ size_t PoolRawAccess::getSerializedSize() const {
 }
 
 ReturnValue_t PoolRawAccess::deSerialize(const uint8_t **buffer, size_t *size,
-		bool bigEndian) {
+        Endianness streamEndianness) {
-	// TODO: Needs to be tested!!!
+
     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;
-		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;
     }

datapoolglob/PoolRawAccess.h

@@ -57,8 +57,8 @@ public:
 	 * @return	- @c RETURN_OK if entry could be acquired
 	 * 			- @c RETURN_FAILED else.
 	 */
-	ReturnValue_t getEntryEndianSafe(uint8_t* buffer, uint32_t* size,
+	ReturnValue_t getEntryEndianSafe(uint8_t *buffer, size_t *size,
-			uint32_t max_size);
+			size_t maxSize);
 
 	/**
 	 * @brief 	Serialize raw pool entry into provided buffer directly
@@ -70,7 +70,12 @@ public:
 	 *         - @c SerializeIF::BUFFER_TOO_SHORT if range check failed
 	 */
 	ReturnValue_t serialize(uint8_t **buffer, size_t *size,
-			const size_t max_size, bool bigEndian) const;
+	        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.
@@ -80,7 +85,7 @@ public:
 	 * 			- @c RETURN_FAILED on failure
 	 */
 	ReturnValue_t setEntryFromBigEndian(const uint8_t* buffer,
-			uint32_t setSize);
+			size_t setSize);
 	/**
 	 *  @brief This operation returns the type of the entry currently stored.
 	 */
@@ -88,12 +93,12 @@ public:
 	/**
 	 *  @brief This operation returns the size of the entry currently stored.
 	 */
-	uint8_t getSizeOfType();
+	size_t getSizeOfType();
 	/**
 	 *
 	 * @return the size of the datapool array
 	 */
-	uint8_t getArraySize();
+	size_t getArraySize();
 	/**
 	 * @brief	This operation returns the data pool id of the variable.
 	 */
@@ -128,12 +133,7 @@ public:
 	/**
 	 * Getter for the remaining size.
 	 */
-	uint16_t getSizeTillEnd() const;
+	size_t getSizeTillEnd() const;
-
-	size_t getSerializedSize() const;
-
-	ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
-			bool bigEndian);
 
 	/**
 	 * @brief	This is a call to read the value from the global data pool.
@@ -202,15 +202,15 @@ private:
 	/**
 	 * @brief	This value contains the size of the data pool entry type in bytes.
 	 */
-	uint8_t typeSize;
+	size_t typeSize;
 	/**
 	 * The size of the DP array (single values return 1)
 	 */
-	uint8_t arraySize;
+	size_t arraySize;
 	/**
 	 * The size (in bytes) from the selected entry till the end of this DataPool variable.
 	 */
-	uint16_t sizeTillEnd;
+	size_t sizeTillEnd;
 	/**
 	 * @brief	The information whether the class is read-write or read-only is stored here.
 	 */

datapoollocal/LocalDataPoolManager.cpp

@@ -1,5 +1,6 @@
 #include <framework/datapoollocal/LocalDataPoolManager.h>
 #include <framework/datapoollocal/LocalDataSet.h>
+#include <framework/housekeeping/AcceptsHkPacketsIF.h>
 #include <framework/ipc/MutexFactory.h>
 #include <framework/ipc/MutexHelper.h>
 #include <framework/ipc/QueueFactory.h>
@@ -7,7 +8,7 @@
 #include <array>
 
 LocalDataPoolManager::LocalDataPoolManager(OwnsLocalDataPoolIF* owner,
-        uint32_t replyQueueDepth, bool appendValidityBuffer):
+        MessageQueueIF* queueToUse, bool appendValidityBuffer):
         appendValidityBuffer(appendValidityBuffer) {
 	if(owner == nullptr) {
 		sif::error << "HkManager: Invalid supplied owner!" << std::endl;
@@ -24,16 +25,45 @@ LocalDataPoolManager::LocalDataPoolManager(OwnsLocalDataPoolIF* owner,
 	    sif::error << "LocalDataPoolManager::LocalDataPoolManager: "
 	            "Could not set IPC store." << std::endl;
 	}
-	hkQueue = QueueFactory::instance()->createMessageQueue(replyQueueDepth,
+	hkQueue = queueToUse;
-	        HousekeepingMessage::HK_MESSAGE_SIZE);
+}
+
+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 =
+		ReturnValue_t result = owner->initializePoolEntries(localDpMap);
-				owner->initializePoolEntries(localDpMap);
 		if(result == HasReturnvaluesIF::RETURN_OK) {
 			mapInitialized = true;
 		}
@@ -80,16 +110,12 @@ MutexIF* LocalDataPoolManager::getMutexHandle() {
 	return mutex;
 }
 
-void LocalDataPoolManager::setHkPacketDestination(
-        MessageQueueId_t destinationQueueId) {
-    this->currentHkPacketDestination = destinationQueueId;
-}
-
 const OwnsLocalDataPoolIF* LocalDataPoolManager::getOwner() const {
     return owner;
 }
 
-ReturnValue_t LocalDataPoolManager::generateHousekeepingPacket(sid_t sid) {
+ReturnValue_t LocalDataPoolManager::generateHousekeepingPacket(sid_t sid,
+        MessageQueueId_t sendTo) {
 	LocalDataSet* dataSetToSerialize = dynamic_cast<LocalDataSet*>(
 			owner->getDataSetHandle(sid));
 	if(dataSetToSerialize == nullptr) {
@@ -108,14 +134,21 @@ ReturnValue_t LocalDataPoolManager::generateHousekeepingPacket(sid_t sid) {
 	CommandMessage hkMessage;
 	HousekeepingMessage::setHkReportMessage(&hkMessage, sid, storeId);
 	if(hkQueue == nullptr) {
-	    return QUEUE_NOT_SET;
+	    return QUEUE_OR_DESTINATION_NOT_SET;
 	}
 
-	if(currentHkPacketDestination != MessageQueueIF::NO_QUEUE) {
+	if(sendTo != MessageQueueIF::NO_QUEUE) {
-	    result = hkQueue->sendMessage(currentHkPacketDestination, &hkMessage);
+	    result = hkQueue->sendMessage(sendTo, &hkMessage);
 	}
 	else {
-	    result = hkQueue->sendToDefault(&hkMessage);
+	    if(hkDestination == MessageQueueIF::NO_QUEUE) {
+	        sif::warning << "LocalDataPoolManager::generateHousekeepingPacket:"
+	                " Destination is not set properly!" << std::endl;
+	        return QUEUE_OR_DESTINATION_NOT_SET;
+	    }
+	    else {
+	        result = hkQueue->sendMessage(hkDestination, &hkMessage);
+	    }
 	}
 
 	return result;
@@ -141,7 +174,7 @@ ReturnValue_t LocalDataPoolManager::generateSetStructurePacket(sid_t sid) {
     }
     size_t size = 0;
     result = dataSet->serializeLocalPoolIds(&storePtr, &size,
-            expectedSize, false);
+            expectedSize, SerializeIF::Endianness::BIG);
     if(expectedSize != size) {
         sif::error << "HousekeepingManager::generateSetStructurePacket: "
                 "Expected size is not equal to serialized size" << std::endl;
@@ -149,6 +182,9 @@ ReturnValue_t LocalDataPoolManager::generateSetStructurePacket(sid_t sid) {
     return result;
 }
 
+void LocalDataPoolManager::setMinimalSamplingFrequency(float frequencySeconds) {
+}
+
 ReturnValue_t LocalDataPoolManager::serializeHkPacketIntoStore(
         store_address_t *storeId, LocalDataSet* dataSet) {
     size_t hkSize = dataSet->getSerializedSize();
@@ -163,10 +199,11 @@ ReturnValue_t LocalDataPoolManager::serializeHkPacketIntoStore(
 
     if(appendValidityBuffer) {
         result = dataSet->serializeWithValidityBuffer(&storePtr,
-                &size, hkSize, false);
+                &size, hkSize, SerializeIF::Endianness::MACHINE);
     }
     else {
-        result = dataSet->serialize(&storePtr, &size, hkSize, false);
+        result = dataSet->serialize(&storePtr, &size, hkSize,
+                SerializeIF::Endianness::MACHINE);
     }
 
     if(result != HasReturnvaluesIF::RETURN_OK) {
@@ -177,4 +214,3 @@ ReturnValue_t LocalDataPoolManager::serializeHkPacketIntoStore(
 }
 
 
-

datapoollocal/LocalDataPoolManager.h

@@ -44,18 +44,45 @@ public:
     static constexpr ReturnValue_t POOL_ENTRY_NOT_FOUND = MAKE_RETURN_CODE(0x0);
     static constexpr ReturnValue_t POOL_ENTRY_TYPE_CONFLICT = MAKE_RETURN_CODE(0x1);
 
-    static constexpr ReturnValue_t QUEUE_NOT_SET = MAKE_RETURN_CODE(0x2);
+    static constexpr ReturnValue_t QUEUE_OR_DESTINATION_NOT_SET = MAKE_RETURN_CODE(0x2);
     //static constexpr ReturnValue_t SET_NOT_FOUND = MAKE_RETURN_CODE(0x3);
 
-	LocalDataPoolManager(OwnsLocalDataPoolIF* owner,
+    /**
-	        uint32_t replyQueueDepth = 20, bool appendValidityBuffer = true);
+     * This constructor is used by a class which wants to implement
+     * a personal local data pool. The queueToUse can be supplied if it
+     * is already known.
+     *
+     * initialize() has to be called in any case before using the object!
+     * @param owner
+     * @param queueToUse
+     * @param appendValidityBuffer
+     */
+	LocalDataPoolManager(OwnsLocalDataPoolIF* owner, MessageQueueIF* queueToUse,
+	        bool appendValidityBuffer = true);
+	/**
+	 * Initializes the map by calling the map initialization function of the
+	 * owner abd assigns the queue to use.
+	 * @param queueToUse
+	 * @return
+	 */
+	ReturnValue_t initialize(MessageQueueIF* queueToUse,
+	        object_id_t hkDestination);
+	/**
+	 * This function is used to set the default HK packet destination.
+	 * This destination will usually only be set once.
+	 * @param hkDestination
+	 */
+	void setHkPacketDestination(MessageQueueId_t hkDestination);
+
 	virtual~ LocalDataPoolManager();
 
-	/* Copying forbidden */
+	/**
-	LocalDataPoolManager(const LocalDataPoolManager &) = delete;
+	 * Generate a housekeeping packet with a given SID.
-	LocalDataPoolManager operator=(const LocalDataPoolManager&) = delete;
+	 * @param sid
-
+	 * @return
-	ReturnValue_t generateHousekeepingPacket(sid_t sid);
+	 */
+	ReturnValue_t generateHousekeepingPacket(sid_t sid, MessageQueueId_t sendTo
+	        = MessageQueueIF::NO_QUEUE);
 	ReturnValue_t generateSetStructurePacket(sid_t sid);
 
 	ReturnValue_t handleHousekeepingMessage(CommandMessage* message);
@@ -68,40 +95,43 @@ public:
 	 */
 	ReturnValue_t initializeHousekeepingPoolEntriesOnce();
 
-	//! Set the queue for HK packets, which are sent unrequested.
-	void setHkPacketDestination(MessageQueueId_t destinationQueueId);
-
 	const OwnsLocalDataPoolIF* getOwner() const;
 
 	ReturnValue_t printPoolEntry(lp_id_t localPoolId);
 
+    /* Copying forbidden */
+    LocalDataPoolManager(const LocalDataPoolManager &) = delete;
+    LocalDataPoolManager operator=(const LocalDataPoolManager&) = delete;
 private:
-	//! This is the map holding the actual data. Should only be initialized
+	/** This is the map holding the actual data. Should only be initialized
-	//! once !
+	 * once ! */
 	bool mapInitialized = false;
-	//! This specifies whether a validity buffer is appended at the end
+	/** This specifies whether a validity buffer is appended at the end
-	//! of generated housekeeping packets.
+	 * of generated housekeeping packets. */
 	bool appendValidityBuffer = true;
 
 	LocalDataPool localDpMap;
 
-	//! Every housekeeping data manager has a mutex to protect access
+	/** Every housekeeping data manager has a mutex to protect access
-	//! to it's data pool.
+	 * to it's data pool. */
 	MutexIF * mutex = nullptr;
-
+	/** The class which actually owns the manager (and its datapool). */
-	//! The class which actually owns the manager (and its datapool).
 	OwnsLocalDataPoolIF* owner = nullptr;
-
+	/**
-	//! Queue used for communication, for example commands.
+	 * @brief Queue used for communication, for example commands.
-	//! Is also used to send messages.
+	 * 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
+	 * HK replies will always be a reply to the commander, but HK packet
-	//! ID, for example to a dedicated housekeeping service implementation.
+	 * can be sent to another destination by specifying this message queue
-	MessageQueueId_t currentHkPacketDestination = MessageQueueIF::NO_QUEUE;
+	 * ID, for example to a dedicated housekeeping service implementation.
+	 */
+	MessageQueueId_t hkDestination = MessageQueueIF::NO_QUEUE;
 
-	//! Global IPC store is used to store all packets.
+	/** Global IPC store is used to store all packets. */
 	StorageManagerIF* ipcStore = nullptr;
 	/**
 	 * Get the pointer to the mutex. Can be used to lock the data pool

datapoollocal/LocalDataSet.cpp

@@ -5,20 +5,30 @@
 #include <cmath>
 #include <cstring>
 
-LocalDataSet::LocalDataSet(OwnsLocalDataPoolIF *hkOwner): DataSetBase() {
+LocalDataSet::LocalDataSet(OwnsLocalDataPoolIF *hkOwner,
+        const size_t maxNumberOfVariables):
+        DataSetBase(poolVarList.data(), maxNumberOfVariables) {
+    poolVarList.reserve(maxNumberOfVariables);
+    poolVarList.resize(maxNumberOfVariables);
     if(hkOwner == nullptr) {
         sif::error << "LocalDataSet::LocalDataSet: Owner can't be nullptr!"
                 << std::endl;
+        return;
     }
     hkManager = hkOwner->getHkManagerHandle();
 }
 
-LocalDataSet::LocalDataSet(object_id_t ownerId): DataSetBase()  {
+LocalDataSet::LocalDataSet(object_id_t ownerId,
+        const size_t maxNumberOfVariables):
+        DataSetBase(poolVarList.data(), maxNumberOfVariables)  {
+    poolVarList.reserve(maxNumberOfVariables);
+    poolVarList.resize(maxNumberOfVariables);
     OwnsLocalDataPoolIF* hkOwner = objectManager->get<OwnsLocalDataPoolIF>(
             ownerId);
     if(hkOwner == nullptr) {
         sif::error << "LocalDataSet::LocalDataSet: Owner can't be nullptr!"
                 << std::endl;
+        return;
     }
     hkManager = hkOwner->getHkManagerHandle();
 }
@@ -32,7 +42,8 @@ ReturnValue_t LocalDataSet::lockDataPool(uint32_t timeoutMs) {
 }
 
 ReturnValue_t LocalDataSet::serializeWithValidityBuffer(uint8_t **buffer,
-        size_t *size, const size_t maxSize, bool bigEndian) const {
+        size_t *size, size_t maxSize,
+        SerializeIF::Endianness streamEndianness) const {
     ReturnValue_t result = HasReturnvaluesIF::RETURN_FAILED;
     uint8_t validityMaskSize = std::ceil(static_cast<float>(fillCount)/8.0);
     uint8_t validityMask[validityMaskSize];
@@ -52,7 +63,7 @@ ReturnValue_t LocalDataSet::serializeWithValidityBuffer(uint8_t **buffer,
             }
         }
         result = registeredVariables[count]->serialize(buffer, size, maxSize,
-                bigEndian);
+                streamEndianness);
         if (result != HasReturnvaluesIF::RETURN_OK) {
             return result;
         }
@@ -69,11 +80,12 @@ ReturnValue_t LocalDataSet::unlockDataPool() {
 }
 
 ReturnValue_t LocalDataSet::serializeLocalPoolIds(uint8_t** buffer,
-        size_t* size, const size_t maxSize, bool bigEndian) const {
+        size_t* size, size_t maxSize,
+        SerializeIF::Endianness streamEndianness) const {
     for (uint16_t count = 0; count < fillCount; count++) {
         lp_id_t currentPoolId = registeredVariables[count]->getDataPoolId();
-        auto result = AutoSerializeAdapter::serialize(&currentPoolId, buffer,
+        auto result = SerializeAdapter::serialize(&currentPoolId, buffer,
-                size, maxSize, bigEndian);
+                size, maxSize, streamEndianness);
         if(result != HasReturnvaluesIF::RETURN_OK) {
             sif::warning << "LocalDataSet::serializeLocalPoolIds: Serialization"
                     " error!" << std::endl;

datapoollocal/LocalDataSet.h

@@ -5,6 +5,8 @@
 #include <framework/datapoollocal/OwnsLocalDataPoolIF.h>
 #include <framework/serialize/SerializeIF.h>
 
+#include <vector>
+
 class LocalDataPoolManager;
 
 /**
@@ -35,7 +37,8 @@ public:
 	 * 			The constructor simply sets the fill_count to zero and sets
 	 *  		the state to "uninitialized".
 	 */
-	LocalDataSet(OwnsLocalDataPoolIF* hkOwner);
+	LocalDataSet(OwnsLocalDataPoolIF *hkOwner,
+	        const size_t maxNumberOfVariables);
 
 	/**
 	 * @brief	Constructor for users of local pool data. The passed pool
@@ -43,7 +46,8 @@ public:
 	 * 			The constructor simply sets the fill_count to zero and sets
 	 *  		the state to "uninitialized".
 	 */
-	LocalDataSet(object_id_t ownerId);
+	LocalDataSet(object_id_t ownerId,
+	        const size_t maxNumberOfVariables);
 
 	/**
 	 * @brief	The destructor automatically manages writing the valid
@@ -68,10 +72,12 @@ public:
 	 * @return
 	 */
 	ReturnValue_t serializeWithValidityBuffer(uint8_t** buffer,
-	        size_t* size, const size_t maxSize, bool bigEndian) const;
+	        size_t* size, size_t maxSize,
+	        SerializeIF::Endianness streamEndianness) const;
 
 	ReturnValue_t serializeLocalPoolIds(uint8_t** buffer,
-            size_t* size, const size_t maxSize, bool bigEndian) const;
+	        size_t* size, size_t maxSize,
+	        SerializeIF::Endianness streamEndianness) const;
 protected:
 private:
 	/**
@@ -102,6 +108,8 @@ private:
 	 * (most significant bit) to 7 (least significant bit)
 	 */
 	void bitSetter(uint8_t* byte, uint8_t position) const;
+
+	std::vector<PoolVariableIF*> poolVarList;
 };
 
 #endif /* FRAMEWORK_DATAPOOLLOCAL_LOCALDATASET_H_ */

datapoollocal/LocalPoolVariable.h

@@ -84,11 +84,11 @@ public:
 	void setValid(bool validity) override;
 	uint8_t getValid() const;
 
-	ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+	ReturnValue_t serialize(uint8_t** buffer, size_t* size, size_t maxSize,
-			const size_t max_size, bool bigEndian) const override;
+	        SerializeIF::Endianness streamEndianness) const override;
 	virtual size_t getSerializedSize() const override;
 	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
-			bool bigEndian) override;
+	        SerializeIF::Endianness streamEndianness) override;
 
 	/**
 	 * @brief	This is a call to read the array's values

datapoollocal/LocalPoolVariable.tpp

@@ -133,20 +133,20 @@ inline uint8_t LocalPoolVar<T>::getValid() const {
 
 template<typename T>
 inline ReturnValue_t LocalPoolVar<T>::serialize(uint8_t** buffer, size_t* size,
-		const size_t max_size, bool bigEndian) const {
+		const size_t max_size, SerializeIF::Endianness streamEndianness) const {
-	return AutoSerializeAdapter::serialize(&value,
+	return SerializeAdapter::serialize(&value,
-			buffer, size ,max_size, bigEndian);
+			buffer, size ,max_size, streamEndianness);
 }
 
 template<typename T>
 inline size_t LocalPoolVar<T>::getSerializedSize() const {
-	return AutoSerializeAdapter::getSerializedSize(&value);
+	return SerializeAdapter::getSerializedSize(&value);
 }
 
 template<typename T>
 inline ReturnValue_t LocalPoolVar<T>::deSerialize(const uint8_t** buffer,
-		size_t* size, bool bigEndian) {
+		size_t* size, SerializeIF::Endianness streamEndianness) {
-	return AutoSerializeAdapter::deSerialize(&value, buffer, size, bigEndian);
+	return SerializeAdapter::deSerialize(&value, buffer, size, streamEndianness);
 }
 
 template<typename T>

datapoollocal/LocalPoolVector.h

@@ -114,10 +114,11 @@ public:
 	const T &operator [](int i) const;
 
 	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
-			const size_t max_size, bool bigEndian) const override;
+			const size_t maxSize,
+			SerializeIF::Endianness streamEndiannes) const override;
 	virtual size_t getSerializedSize() const override;
 	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
-			bool bigEndian) override;
+	        SerializeIF::Endianness streamEndianness) override;
 
 	/**
 	 * @brief	This is a call to read the array's values

datapoollocal/LocalPoolVector.tpp

@@ -125,11 +125,12 @@ inline const T& LocalPoolVector<T, vectorSize>::operator [](int i) const {
 
 template<typename T, uint16_t vectorSize>
 inline ReturnValue_t LocalPoolVector<T, vectorSize>::serialize(uint8_t** buffer,
-		size_t* size, const size_t max_size, bool bigEndian) const {
+		size_t* size, size_t maxSize,
+		SerializeIF::Endianness streamEndianness) const {
 	ReturnValue_t result = HasReturnvaluesIF::RETURN_FAILED;
 	for (uint16_t i = 0; i < vectorSize; i++) {
-		result = SerializeAdapter<T>::serialize(&(value[i]), buffer, size,
+		result = SerializeAdapter::serialize(&(value[i]), buffer, size,
-				max_size, bigEndian);
+				maxSize, streamEndianness);
 		if (result != HasReturnvaluesIF::RETURN_OK) {
 			break;
 		}
@@ -139,16 +140,17 @@ inline ReturnValue_t LocalPoolVector<T, vectorSize>::serialize(uint8_t** buffer,
 
 template<typename T, uint16_t vectorSize>
 inline size_t LocalPoolVector<T, vectorSize>::getSerializedSize() const {
-	return vectorSize * SerializeAdapter<T>::getSerializedSize(value);
+	return vectorSize * SerializeAdapter::getSerializedSize(value);
 }
 
 template<typename T, uint16_t vectorSize>
 inline ReturnValue_t LocalPoolVector<T, vectorSize>::deSerialize(
-		const uint8_t** buffer, size_t* size, bool bigEndian) {
+		const uint8_t** buffer, size_t* size,
+		SerializeIF::Endianness streamEndianness) {
 	ReturnValue_t result = HasReturnvaluesIF::RETURN_FAILED;
 	for (uint16_t i = 0; i < vectorSize; i++) {
-		result = SerializeAdapter<T>::deSerialize(&(value[i]), buffer, size,
+		result = SerializeAdapter::deSerialize(&(value[i]), buffer, size,
-				bigEndian);
+				streamEndianness);
 		if (result != HasReturnvaluesIF::RETURN_OK) {
 			break;
 		}

datapoollocal/StaticLocalDataSet.cpp

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

datapoollocal/StaticLocalDataSet.h

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

devicehandlers/AcceptsDeviceResponsesIF.h

@@ -1,15 +1,12 @@
-/**
+#ifndef FRAMEWORK_DEVICEHANDLERS_ACCEPTSDEVICERESPONSESIF_H_
- * @file	AcceptsDeviceResponsesIF.h
+#define FRAMEWORK_DEVICEHANDLERS_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:
 	/**
@@ -19,4 +16,4 @@ public:
 	virtual MessageQueueId_t getDeviceQueue() = 0;
 };
 
-#endif /* ACCEPTSDEVICERESPONSESIF_H_ */
+#endif /* FRAMEWORK_DEVICEHANDLERS_ACCEPTSDEVICERESPONSESIF_H_ */

devicehandlers/ChildHandlerBase.cpp

@@ -5,10 +5,11 @@
 ChildHandlerBase::ChildHandlerBase(object_id_t setObjectId,
 		object_id_t deviceCommunication, CookieIF * cookie,
 		uint32_t maxDeviceReplyLen, uint8_t setDeviceSwitch,
-		uint32_t thermalStatePoolId, uint32_t thermalRequestPoolId,
+		object_id_t hkDestination, uint32_t thermalStatePoolId,
-		uint32_t parent, FailureIsolationBase* customFdir, size_t cmdQueueSize) :
+		uint32_t thermalRequestPoolId, uint32_t parent,
+		FailureIsolationBase* customFdir, size_t cmdQueueSize) :
 		DeviceHandlerBase(setObjectId, deviceCommunication, cookie,
-			setDeviceSwitch,  thermalStatePoolId,
+		    hkDestination, setDeviceSwitch,  thermalStatePoolId,
 			thermalRequestPoolId, (customFdir == NULL? &childHandlerFdir : customFdir),
 			cmdQueueSize),
 		parentId(parent), childHandlerFdir(setObjectId) {

devicehandlers/ChildHandlerBase.h

@@ -8,9 +8,9 @@ class ChildHandlerBase: public DeviceHandlerBase {
 public:
 	ChildHandlerBase(object_id_t setObjectId, object_id_t deviceCommunication,
 			CookieIF * cookie, uint32_t maxDeviceReplyLen, uint8_t setDeviceSwitch,
-			uint32_t thermalStatePoolId, uint32_t thermalRequestPoolId,
+			object_id_t hkDestination, uint32_t thermalStatePoolId,
-			uint32_t parent, FailureIsolationBase* customFdir = nullptr,
+			uint32_t thermalRequestPoolId, uint32_t parent,
-			size_t cmdQueueSize = 20);
+			FailureIsolationBase* customFdir = nullptr, size_t cmdQueueSize = 20);
 	virtual ~ChildHandlerBase();
 
 	virtual ReturnValue_t initialize();

devicehandlers/DeviceHandlerBase.cpp

@@ -22,21 +22,21 @@ object_id_t DeviceHandlerBase::defaultFDIRParentId = 0;
 
 DeviceHandlerBase::DeviceHandlerBase(object_id_t setObjectId,
 		object_id_t deviceCommunication, CookieIF * comCookie,
-		uint8_t setDeviceSwitch, uint32_t thermalStatePoolId,
+		uint8_t setDeviceSwitch, object_id_t hkDestination,
-		uint32_t thermalRequestPoolId, FailureIsolationBase* fdirInstance,
+		uint32_t thermalStatePoolId, uint32_t thermalRequestPoolId,
-		size_t cmdQueueSize) :
+		FailureIsolationBase* fdirInstance, size_t cmdQueueSize) :
 		SystemObject(setObjectId), mode(MODE_OFF), submode(SUBMODE_NONE),
 		wiretappingMode(OFF), storedRawData(StorageManagerIF::INVALID_ADDRESS),
 		deviceCommunicationId(deviceCommunication), comCookie(comCookie),
 		healthHelper(this,setObjectId), modeHelper(this), parameterHelper(this),
-		actionHelper(this, nullptr), hkManager(this),
+		actionHelper(this, nullptr), hkManager(this, nullptr),
 		deviceThermalStatePoolId(thermalStatePoolId),
 		deviceThermalRequestPoolId(thermalRequestPoolId),
 		childTransitionFailure(RETURN_OK), fdirInstance(fdirInstance),
 		hkSwitcher(this), defaultFDIRUsed(fdirInstance == nullptr),
-		switchOffWasReported(false), childTransitionDelay(5000),
+		switchOffWasReported(false), hkDestination(hkDestination),
-		transitionSourceMode(_MODE_POWER_DOWN), transitionSourceSubMode(
+		childTransitionDelay(5000), transitionSourceMode(_MODE_POWER_DOWN),
-		SUBMODE_NONE), deviceSwitch(setDeviceSwitch) {
+		transitionSourceSubMode(SUBMODE_NONE), deviceSwitch(setDeviceSwitch) {
 	commandQueue = QueueFactory::instance()->createMessageQueue(cmdQueueSize,
 			MessageQueueMessage::MAX_MESSAGE_SIZE);
 	insertInCommandMap(RAW_COMMAND_ID);
@@ -128,8 +128,12 @@ ReturnValue_t DeviceHandlerBase::initialize() {
 		AcceptsDeviceResponsesIF *rawReceiver = objectManager->get<
 				AcceptsDeviceResponsesIF>(rawDataReceiverId);
 
-		if (rawReceiver == NULL) {
+		if (rawReceiver == nullptr) {
-			return RETURN_FAILED;
+			sif::error << "DeviceHandlerBase::initialize: Raw receiver object "
+					"ID set but no valid object found." << std::endl;
+			sif::error << "Make sure the raw receiver object is set up properly"
+					" and implements AcceptsDeviceResponsesIF" << std::endl;
+			return ObjectManagerIF::CHILD_INIT_FAILED;
 		}
 		defaultRawReceiver = rawReceiver->getDeviceQueue();
 	}
@@ -173,7 +177,7 @@ ReturnValue_t DeviceHandlerBase::initialize() {
 		return result;
 	}
 
-	result = hkManager.initializeHousekeepingPoolEntriesOnce();
+	result = hkManager.initialize(commandQueue, hkDestination);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}
@@ -315,6 +319,12 @@ void DeviceHandlerBase::doStateMachine() {
 	case _MODE_WAIT_OFF: {
 		uint32_t currentUptime;
 		Clock::getUptime(&currentUptime);
+
+		if(powerSwitcher == nullptr) {
+		    setMode(MODE_OFF);
+		    return;
+		}
+
 		if (currentUptime - timeoutStart >= powerSwitcher->getSwitchDelayMs()) {
 			triggerEvent(MODE_TRANSITION_FAILED, PowerSwitchIF::SWITCH_TIMEOUT,
 					0);
@@ -696,19 +706,23 @@ void DeviceHandlerBase::handleReply(const uint8_t* receivedData,
 
 	if (info->delayCycles != 0) {
 
-		if (info->periodic != 0) {
+		if (info->periodic != false) {
 			info->delayCycles = info->maxDelayCycles;
-		} else {
+		}
+		else {
 			info->delayCycles = 0;
 		}
+
 		result = interpretDeviceReply(foundId, receivedData);
+
 		if (result != RETURN_OK) {
 			// Report failed interpretation to FDIR.
 			replyRawReplyIfnotWiretapped(receivedData, foundLen);
 			triggerEvent(DEVICE_INTERPRETING_REPLY_FAILED, result, foundId);
 		}
 		replyToReply(iter, result);
-	} else {
+	}
+	else {
 		// Other completion failure messages are created by timeout.
 		// Powering down the device might take some time during which periodic
 		// replies may still come in.

devicehandlers/DeviceHandlerBase.h

@@ -107,6 +107,7 @@ public:
 	 */
 	DeviceHandlerBase(object_id_t setObjectId, object_id_t deviceCommunication,
 			CookieIF * comCookie, uint8_t setDeviceSwitch,
+			object_id_t hkDestination = objects::NO_OBJECT,
 			uint32_t thermalStatePoolId = PoolVariableIF::NO_PARAMETER,
 			uint32_t thermalRequestPoolId = PoolVariableIF::NO_PARAMETER,
 			FailureIsolationBase* fdirInstance = nullptr,
@@ -652,11 +653,13 @@ protected:
 		size_t replyLen = 0; //!< Expected size of the reply.
 		//! if this is !=0, the delayCycles will not be reset to 0 but to
 		//! maxDelayCycles
-		bool periodic;
+		bool periodic = false;
 		//! The dataset used to access housekeeping data related to the
 		//! respective device reply. Will point to a dataset held by
 		//! the child handler (if one is specified)
-		DataSetIF* dataSet;
+		DataSetIF* dataSet = nullptr;
+		float collectionInterval = 0.0;
+		uint32_t intervalCounter = 0;
 		//! The command that expects this reply.
 		DeviceCommandMap::iterator command;
 	};
@@ -1035,8 +1038,7 @@ private:
 	};
 
 	/**
-	 * Info about the #cookie
+	 * @brief   Info about the #cookie
-	 *
 	 * Used to track the state of the communication
 	 */
 	CookieInfo cookieInfo;
@@ -1044,9 +1046,11 @@ private:
 	/** the object used to set power switches */
 	PowerSwitchIF *powerSwitcher = nullptr;
 
+	/** Cached for initialize() */
+	object_id_t hkDestination = objects::NO_OBJECT;
+
 	/**
-	 * Used for timing out mode transitions.
+	 * @brief   Used for timing out mode transitions.
-	 *
 	 * Set when setMode() is called.
 	 */
 	uint32_t timeoutStart = 0;
@@ -1057,11 +1061,12 @@ private:
 	uint32_t childTransitionDelay;
 
 	/**
-	 * The mode the current transition originated from
+	 * @brief   The mode the current transition originated from
 	 *
 	 * This is private so the child can not change it and fuck up the timeouts
 	 *
-	 * IMPORTANT: This is not valid during _MODE_SHUT_DOWN and _MODE_START_UP!! (it is _MODE_POWER_DOWN during this modes)
+	 * IMPORTANT: This is not valid during _MODE_SHUT_DOWN and _MODE_START_UP!!
+	 * (it is _MODE_POWER_DOWN during this modes)
 	 *
 	 * is element of [MODE_ON, MODE_NORMAL, MODE_RAW]
 	 */

devicehandlers/DeviceTmReportingWrapper.cpp

@@ -12,18 +12,18 @@ DeviceTmReportingWrapper::~DeviceTmReportingWrapper() {
 }
 
 ReturnValue_t DeviceTmReportingWrapper::serialize(uint8_t** buffer,
-		size_t* size, const size_t max_size, bool bigEndian) const {
+		size_t* size, size_t maxSize, Endianness streamEndianness) const {
-	ReturnValue_t result = SerializeAdapter<object_id_t>::serialize(&objectId,
+	ReturnValue_t result = SerializeAdapter::serialize(&objectId,
-			buffer, size, max_size, bigEndian);
+			buffer, size, maxSize, streamEndianness);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}
-	result = SerializeAdapter<ActionId_t>::serialize(&actionId, buffer,
+	result = SerializeAdapter::serialize(&actionId, buffer,
-			size, max_size, bigEndian);
+			size, maxSize, streamEndianness);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}
-	return data->serialize(buffer, size, max_size, bigEndian);
+	return data->serialize(buffer, size, maxSize, streamEndianness);
 }
 
 size_t DeviceTmReportingWrapper::getSerializedSize() const {
@@ -31,16 +31,16 @@ size_t DeviceTmReportingWrapper::getSerializedSize() const {
 }
 
 ReturnValue_t DeviceTmReportingWrapper::deSerialize(const uint8_t** buffer,
-		size_t* size, bool bigEndian) {
+		size_t* size, Endianness streamEndianness) {
-	ReturnValue_t result = SerializeAdapter<object_id_t>::deSerialize(&objectId,
+	ReturnValue_t result = SerializeAdapter::deSerialize(&objectId,
-			buffer, size, bigEndian);
+			buffer, size, streamEndianness);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}
-	result = SerializeAdapter<ActionId_t>::deSerialize(&actionId, buffer,
+	result = SerializeAdapter::deSerialize(&actionId, buffer,
-			size, bigEndian);
+			size, streamEndianness);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}
-	return data->deSerialize(buffer, size, bigEndian);
+	return data->deSerialize(buffer, size, streamEndianness);
 }

devicehandlers/DeviceTmReportingWrapper.h

@@ -12,12 +12,12 @@ public:
 	virtual ~DeviceTmReportingWrapper();
 
 	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
-			const size_t max_size, bool bigEndian) const;
+			size_t maxSize, Endianness streamEndianness) const override;
 
-	virtual size_t getSerializedSize() const;
+	virtual size_t getSerializedSize() const override;
 
 	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
-			bool bigEndian);
+			Endianness streamEndianness) override;
 private:
 	object_id_t objectId;
 	ActionId_t actionId;

events/eventmatching/EventRangeMatcherBase.h

@@ -12,15 +12,15 @@ public:
 	EventRangeMatcherBase(T from, T till, bool inverted) : rangeMatcher(from, till, inverted) {	}
 	virtual ~EventRangeMatcherBase() { }
 	ReturnValue_t serialize(uint8_t** buffer, size_t* size,
-			const size_t max_size, bool bigEndian) const {
+			size_t maxSize, Endianness streamEndianness) const {
-		return rangeMatcher.serialize(buffer, size, max_size, bigEndian);
+		return rangeMatcher.serialize(buffer, size, maxSize, streamEndianness);
 	}
 	size_t getSerializedSize() const {
 		return rangeMatcher.getSerializedSize();
 	}
 	ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
-			bool bigEndian) {
+			Endianness streamEndianness) {
-		return rangeMatcher.deSerialize(buffer, size, bigEndian);
+		return rangeMatcher.deSerialize(buffer, size, streamEndianness);
 	}
 protected:
 	RangeMatcher<T> rangeMatcher;

fdir/FailureIsolationBase.cpp

@@ -35,8 +35,10 @@ ReturnValue_t FailureIsolationBase::initialize() {
 			return result;
 		}
 		owner = objectManager->get<HasHealthIF>(ownerId);
-		if (owner == NULL) {
+		if (owner == nullptr) {
-			return RETURN_FAILED;
+			sif::error << "FailureIsolationBase::intialize: Owner object "
+					"invalid. Make sure it implements HasHealthIF" << std::endl;
+			return ObjectManagerIF::CHILD_INIT_FAILED;
 		}
 	}
 	if (faultTreeParent != 0) {

globalfunctions/Type.cpp

@@ -59,7 +59,7 @@ uint8_t Type::getSize() const {
 }
 
 ReturnValue_t Type::serialize(uint8_t** buffer, size_t* size,
-		const size_t max_size, bool bigEndian) const {
+		size_t maxSize, Endianness streamEndianness) const {
 	uint8_t ptc;
 	uint8_t pfc;
 	ReturnValue_t result = getPtcPfc(&ptc, &pfc);
@@ -67,14 +67,14 @@ ReturnValue_t Type::serialize(uint8_t** buffer, size_t* size,
 		return result;
 	}
 
-	result = SerializeAdapter<uint8_t>::serialize(&ptc, buffer, size, max_size,
+	result = SerializeAdapter::serialize(&ptc, buffer, size, maxSize,
-			bigEndian);
+			streamEndianness);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}
 
-	result = SerializeAdapter<uint8_t>::serialize(&pfc, buffer, size, max_size,
+	result = SerializeAdapter::serialize(&pfc, buffer, size, maxSize,
-			bigEndian);
+			streamEndianness);
 
 	return result;
 
@@ -82,21 +82,21 @@ ReturnValue_t Type::serialize(uint8_t** buffer, size_t* size,
 
 size_t Type::getSerializedSize() const {
 	uint8_t dontcare = 0;
-	return 2 * SerializeAdapter<uint8_t>::getSerializedSize(&dontcare);
+	return 2 * SerializeAdapter::getSerializedSize(&dontcare);
 }
 
 ReturnValue_t Type::deSerialize(const uint8_t** buffer, size_t* size,
-		bool bigEndian) {
+		Endianness streamEndianness) {
 	uint8_t ptc;
 	uint8_t pfc;
-	ReturnValue_t result = SerializeAdapter<uint8_t>::deSerialize(&ptc, buffer,
+	ReturnValue_t result = SerializeAdapter::deSerialize(&ptc, buffer,
-			size, bigEndian);
+			size, streamEndianness);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}
 
-	result = SerializeAdapter<uint8_t>::deSerialize(&pfc, buffer, size,
+	result = SerializeAdapter::deSerialize(&pfc, buffer, size,
-			bigEndian);
+			streamEndianness);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}

globalfunctions/Type.h

@@ -43,12 +43,12 @@ public:
 	static ActualType_t getActualType(uint8_t ptc, uint8_t pfc);
 
 	virtual ReturnValue_t serialize(uint8_t **buffer, size_t *size,
-			const size_t max_size, bool bigEndian) const;
+			size_t maxSize, Endianness streamEndianness) const override;
 
-	virtual size_t getSerializedSize() const;
+	virtual size_t getSerializedSize() const override;
 
 	virtual ReturnValue_t deSerialize(const uint8_t **buffer, size_t *size,
-			bool bigEndian);
+			Endianness streamEndianness) override;
 
 private:
 	ActualType_t actualType;

globalfunctions/conversion.cpp

@@ -1,104 +0,0 @@
-#include <framework/globalfunctions/conversion.h>
-#include <framework/osal/Endiness.h>
-#include <cstring>
-
-
-
-//SHOULDDO: This shall be optimized (later)!
-void convertToByteStream( uint16_t value, uint8_t* buffer, uint32_t* size ) {
-	buffer[0] = (value & 0xFF00) >> 8;
-	buffer[1] = (value & 0x00FF);
-	*size += 2;
-}
-
-void convertToByteStream( uint32_t value, uint8_t* buffer, uint32_t* size ) {
-	buffer[0] = (value & 0xFF000000) >> 24;
-	buffer[1] = (value & 0x00FF0000) >> 16;
-	buffer[2] = (value & 0x0000FF00) >> 8;
-	buffer[3] = (value & 0x000000FF);
-	*size +=4;
-}
-
-void convertToByteStream( int16_t value, uint8_t* buffer, uint32_t* size ) {
-	buffer[0] = (value & 0xFF00) >> 8;
-	buffer[1] = (value & 0x00FF);
-	*size += 2;
-}
-
-void convertToByteStream( int32_t value, uint8_t* buffer, uint32_t* size ) {
-	buffer[0] = (value & 0xFF000000) >> 24;
-	buffer[1] = (value & 0x00FF0000) >> 16;
-	buffer[2] = (value & 0x0000FF00) >> 8;
-	buffer[3] = (value & 0x000000FF);
-	*size += 4;
-}
-
-//void convertToByteStream( uint64_t value, uint8_t* buffer, uint32_t* size ) {
-//	buffer[0] = (value & 0xFF00000000000000) >> 56;
-//	buffer[1] = (value & 0x00FF000000000000) >> 48;
-//	buffer[2] = (value & 0x0000FF0000000000) >> 40;
-//	buffer[3] = (value & 0x000000FF00000000) >> 32;
-//	buffer[4] = (value & 0x00000000FF000000) >> 24;
-//	buffer[5] = (value & 0x0000000000FF0000) >> 16;
-//	buffer[6] = (value & 0x000000000000FF00) >> 8;
-//	buffer[7] = (value & 0x00000000000000FF);
-//	*size+=8;
-//}
-//
-//void convertToByteStream( int64_t value, uint8_t* buffer, uint32_t* size ) {
-//	buffer[0] = (value & 0xFF00000000000000) >> 56;
-//	buffer[1] = (value & 0x00FF000000000000) >> 48;
-//	buffer[2] = (value & 0x0000FF0000000000) >> 40;
-//	buffer[3] = (value & 0x000000FF00000000) >> 32;
-//	buffer[4] = (value & 0x00000000FF000000) >> 24;
-//	buffer[5] = (value & 0x0000000000FF0000) >> 16;
-//	buffer[6] = (value & 0x000000000000FF00) >> 8;
-//	buffer[7] = (value & 0x00000000000000FF);
-//	*size+=8;
-//}
-
-void convertToByteStream( float in_value, uint8_t* buffer, uint32_t* size ) {
-#ifndef BYTE_ORDER_SYSTEM
-	#error BYTE_ORDER_SYSTEM not defined
-#elif BYTE_ORDER_SYSTEM == LITTLE_ENDIAN
-	union float_union {
-		float value;
-		uint8_t chars[4];
-	};
-	float_union temp;
-	temp.value = in_value;
-	buffer[0] = temp.chars[3];
-	buffer[1] = temp.chars[2];
-	buffer[2] = temp.chars[1];
-	buffer[3] = temp.chars[0];
-	*size += 4;
-#elif BYTE_ORDER_SYSTEM == BIG_ENDIAN
-	memcpy(buffer, &in_value, sizeof(in_value));
-	*size += sizeof(in_value);
-#endif
-}
-
-void convertToByteStream( double in_value, uint8_t* buffer, uint32_t* size ) {
-#ifndef BYTE_ORDER_SYSTEM
-	#error BYTE_ORDER_SYSTEM not defined
-#elif BYTE_ORDER_SYSTEM == LITTLE_ENDIAN
-	union double_union {
-		double value;
-		uint8_t chars[8];
-	};
-	double_union temp;
-	temp.value = in_value;
-	buffer[0] = temp.chars[7];
-	buffer[1] = temp.chars[6];
-	buffer[2] = temp.chars[5];
-	buffer[3] = temp.chars[4];
-	buffer[4] = temp.chars[3];
-	buffer[5] = temp.chars[2];
-	buffer[6] = temp.chars[1];
-	buffer[7] = temp.chars[0];
-	*size += 8;
-#elif BYTE_ORDER_SYSTEM == BIG_ENDIAN
-	memcpy(buffer, &in_value, sizeof(in_value));
-	*size += sizeof(in_value);
-#endif
-}

globalfunctions/conversion.h

@@ -1,24 +0,0 @@
-#ifndef CONVERSION_H_
-#define CONVERSION_H_
-
-
-#include <stdint.h>
-
-
-void convertToByteStream( uint16_t value, uint8_t* buffer, uint32_t* size );
-
-void convertToByteStream( uint32_t value, uint8_t* buffer, uint32_t* size );
-
-void convertToByteStream( int16_t value, uint8_t* buffer, uint32_t* size );
-
-void convertToByteStream( int32_t value, uint8_t* buffer, uint32_t* size );
-
-//void convertToByteStream( uint64_t value, uint8_t* buffer, uint32_t* size );
-//
-//void convertToByteStream( int64_t value, uint8_t* buffer, uint32_t* size );
-
-void convertToByteStream( float value, uint8_t* buffer, uint32_t* size );
-
-void convertToByteStream( double value, uint8_t* buffer, uint32_t* size );
-
-#endif /* CONVERSION_H_ */

globalfunctions/matching/MatchTree.h

@@ -46,37 +46,37 @@ public:
 	}
 
 	ReturnValue_t serialize(uint8_t** buffer, size_t* size,
-			const size_t max_size, bool bigEndian) const {
+			size_t maxSize, SerializeIF::Endianness streamEndianness) const override {
 		iterator iter = this->begin();
 		uint8_t count = this->countRight(iter);
-		ReturnValue_t result = SerializeAdapter<uint8_t>::serialize(&count,
+		ReturnValue_t result = SerializeAdapter::serialize(&count,
-				buffer, size, max_size, bigEndian);
+				buffer, size, maxSize, streamEndianness);
 		if (result != HasReturnvaluesIF::RETURN_OK) {
 			return result;
 		}
 		if (iter == this->end()) {
 			return HasReturnvaluesIF::RETURN_OK;
 		}
-		result = iter->serialize(buffer, size, max_size, bigEndian);
+		result = iter->serialize(buffer, size, maxSize, streamEndianness);
 		if (result != HasReturnvaluesIF::RETURN_OK) {
 			return result;
 		}
 		if (maxDepth > 0) {
 			MatchTree<T> temp(iter.left(), maxDepth - 1);
-			result = temp.serialize(buffer, size, max_size, bigEndian);
+			result = temp.serialize(buffer, size, maxSize, streamEndianness);
 		}
 		if (result != HasReturnvaluesIF::RETURN_OK) {
 			return result;
 		}
 		iter = iter.right();
 		while (iter != this->end()) {
-			result = iter->serialize(buffer, size, max_size, bigEndian);
+			result = iter->serialize(buffer, size, maxSize, streamEndianness);
 			if (result != HasReturnvaluesIF::RETURN_OK) {
 				return result;
 			}
 			if (maxDepth > 0) {
 				MatchTree<T> temp(iter.left(), maxDepth - 1);
-				result = temp.serialize(buffer, size, max_size, bigEndian);
+				result = temp.serialize(buffer, size, maxSize, streamEndianness);
 			}
 			if (result != HasReturnvaluesIF::RETURN_OK) {
 				return result;
@@ -86,7 +86,7 @@ public:
 		return result;
 	}
 
-	size_t getSerializedSize() const {
+	size_t getSerializedSize() const override {
 		//Analogous to serialize!
 		uint32_t size = 1; //One for count
 		iterator iter = this->begin();
@@ -116,7 +116,7 @@ public:
 	}
 
 	ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
-			bool bigEndian) {
+			SerializeIF::Endianness streamEndianness) override {
 		return HasReturnvaluesIF::RETURN_OK;
 	}
 

globalfunctions/matching/RangeMatcher.h

@@ -4,7 +4,6 @@
 #include <framework/globalfunctions/matching/SerializeableMatcherIF.h>
 #include <framework/serialize/SerializeAdapter.h>
 
-
 template<typename T>
 class RangeMatcher: public SerializeableMatcherIF<T> {
 public:
@@ -27,40 +26,40 @@ public:
 		}
 	}
 
-	ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+	ReturnValue_t serialize(uint8_t **buffer, size_t *size, size_t maxSize,
-			const size_t max_size, bool bigEndian) const {
+			SerializeIF::Endianness streamEndianness) const override {
-		ReturnValue_t result = SerializeAdapter<T>::serialize(&lowerBound,
+		ReturnValue_t result = SerializeAdapter::serialize(&lowerBound, buffer,
-				buffer, size, max_size, bigEndian);
+				size, maxSize, streamEndianness);
 		if (result != HasReturnvaluesIF::RETURN_OK) {
 			return result;
 		}
-		result = SerializeAdapter<T>::serialize(&upperBound, buffer, size,
+		result = SerializeAdapter::serialize(&upperBound, buffer, size,
-				max_size, bigEndian);
+				maxSize, streamEndianness);
 		if (result != HasReturnvaluesIF::RETURN_OK) {
 			return result;
 		}
-		return SerializeAdapter<bool>::serialize(&inverted, buffer, size,
+		return SerializeAdapter::serialize(&inverted, buffer, size, maxSize,
-				max_size, bigEndian);
+				streamEndianness);
 	}
 
-	size_t getSerializedSize() const {
+	size_t getSerializedSize() const override {
 		return sizeof(lowerBound) + sizeof(upperBound) + sizeof(bool);
 	}
 
 	ReturnValue_t deSerialize(const uint8_t **buffer, size_t *size,
-			bool bigEndian) {
+			SerializeIF::Endianness streamEndianness) override {
-		ReturnValue_t result = SerializeAdapter<T>::deSerialize(&lowerBound,
+		ReturnValue_t result = SerializeAdapter::deSerialize(&lowerBound,
-				buffer, size, bigEndian);
+				buffer, size, streamEndianness);
 		if (result != HasReturnvaluesIF::RETURN_OK) {
 			return result;
 		}
-		result = SerializeAdapter<T>::deSerialize(&upperBound, buffer,
+		result = SerializeAdapter::deSerialize(&upperBound, buffer, size,
-				size, bigEndian);
+				streamEndianness);
 		if (result != HasReturnvaluesIF::RETURN_OK) {
 			return result;
 		}
-		return SerializeAdapter<bool>::deSerialize(&inverted, buffer,
+		return SerializeAdapter::deSerialize(&inverted, buffer, size,
-				size, bigEndian);
+				streamEndianness);
 	}
 protected:
 	bool doMatch(T input) {

globalfunctions/timevalOperations.cpp

@@ -90,3 +90,10 @@ double timevalOperations::toDouble(const timeval timeval) {
 	double result = timeval.tv_sec * 1000000. + timeval.tv_usec;
 	return result / 1000000.;
 }
+
+timeval timevalOperations::toTimeval(const double seconds) {
+	timeval tval;
+	tval.tv_sec = seconds;
+	tval.tv_usec = seconds *(double) 1e6 - (tval.tv_sec *1e6);
+	return tval;
+}

globalfunctions/timevalOperations.h

@@ -41,6 +41,7 @@ namespace timevalOperations {
  * @return seconds
  */
 double toDouble(const timeval timeval);
+timeval toTimeval(const double seconds);
 }
 
 #endif /* TIMEVALOPERATIONS_H_ */

health/HealthTable.cpp

@@ -63,21 +63,21 @@ bool HealthTable::hasHealth(object_id_t object) {
 	return exits;
 }
 
-void HealthTable::printAll(uint8_t* pointer, uint32_t maxSize) {
+void HealthTable::printAll(uint8_t* pointer, size_t maxSize) {
 	mutex->lockMutex(MutexIF::BLOCKING);
 	size_t size = 0;
 	uint16_t count = healthMap.size();
-	ReturnValue_t result = SerializeAdapter<uint16_t>::serialize(&count,
+	ReturnValue_t result = SerializeAdapter::serialize(&count,
-			&pointer, &size, maxSize, true);
+			&pointer, &size, maxSize, SerializeIF::Endianness::BIG);
 	HealthMap::iterator iter;
 	for (iter = healthMap.begin();
 			iter != healthMap.end() && result == HasReturnvaluesIF::RETURN_OK;
 			++iter) {
-		result = SerializeAdapter<object_id_t>::serialize(&iter->first,
+		result = SerializeAdapter::serialize(&iter->first,
-				&pointer, &size, maxSize, true);
+				&pointer, &size, maxSize, SerializeIF::Endianness::BIG);
 		uint8_t health = iter->second;
-		result = SerializeAdapter<uint8_t>::serialize(&health, &pointer, &size,
+		result = SerializeAdapter::serialize(&health, &pointer, &size,
-				maxSize, true);
+				maxSize, SerializeIF::Endianness::BIG);
 	}
 	mutex->unlockMutex();
 }

health/HealthTable.h

@@ -21,7 +21,7 @@ public:
 	virtual HasHealthIF::HealthState getHealth(object_id_t);
 
 	virtual uint32_t getPrintSize();
-	virtual void printAll(uint8_t *pointer, uint32_t maxSize);
+	virtual void printAll(uint8_t *pointer, size_t maxSize);
 
 protected:
 	MutexIF* mutex;

health/HealthTableIF.h

@@ -19,7 +19,7 @@ public:
 			HasHealthIF::HealthState initilialState = HasHealthIF::HEALTHY) = 0;
 
 	virtual uint32_t getPrintSize() = 0;
-	virtual void printAll(uint8_t *pointer, uint32_t maxSize) = 0;
+	virtual void printAll(uint8_t *pointer, size_t maxSize) = 0;
 
 protected:
 	virtual ReturnValue_t iterate(std::pair<object_id_t,HasHealthIF::HealthState> *value, bool reset = false) = 0;

housekeeping/AcceptsHkPacketsIF.h

@@ -0,0 +1,11 @@
+#ifndef FRAMEWORK_HOUSEKEEPING_ACCEPTSHKPACKETSIF_H_
+#define FRAMEWORK_HOUSEKEEPING_ACCEPTSHKPACKETSIF_H_
+#include <framework/ipc/MessageQueueMessageIF.h>
+
+class AcceptsHkPacketsIF {
+public:
+    virtual~ AcceptsHkPacketsIF() {};
+    virtual MessageQueueId_t getHkQueue() const = 0;
+};
+
+#endif /* FRAMEWORK_HOUSEKEEPING_ACCEPTSHKPACKETSIF_H_ */

memory/MemoryHelper.cpp

@@ -2,7 +2,7 @@
 #include <framework/memory/MemoryHelper.h>
 #include <framework/memory/MemoryMessage.h>
 #include <framework/objectmanager/ObjectManagerIF.h>
-#include <framework/serialize/EndianSwapper.h>
+#include <framework/serialize/EndianConverter.h>
 #include <framework/serviceinterface/ServiceInterfaceStream.h>
 
 MemoryHelper::MemoryHelper(HasMemoryIF* workOnThis,
@@ -44,7 +44,7 @@ void MemoryHelper::completeLoad(ReturnValue_t errorCode,
 		memcpy(copyHere, dataToCopy, size);
 		break;
 	case HasMemoryIF::POINTS_TO_VARIABLE:
-		EndianSwapper::swap(copyHere, dataToCopy, size);
+		EndianConverter::convertBigEndian(copyHere, dataToCopy, size);
 		break;
 	case HasMemoryIF::ACTIVITY_COMPLETED:
 	case RETURN_OK:
@@ -77,7 +77,7 @@ void MemoryHelper::completeDump(ReturnValue_t errorCode,
 	case HasMemoryIF::POINTS_TO_VARIABLE:
 		//"data" must be valid pointer!
 		if (errorCode == HasMemoryIF::POINTS_TO_VARIABLE) {
-			EndianSwapper::swap(reservedSpaceInIPC, dataToCopy, size);
+			EndianConverter::convertBigEndian(reservedSpaceInIPC, dataToCopy, size);
 		} else {
 			memcpy(reservedSpaceInIPC, dataToCopy, size);
 		}
@@ -127,7 +127,7 @@ void MemoryHelper::swapMatrixCopy(uint8_t* out, const uint8_t *in,
 	}
 
 	while (totalSize > 0){
-		EndianSwapper::swap(out,in,datatypeSize);
+		EndianConverter::convertBigEndian(out,in,datatypeSize);
 		out += datatypeSize;
 		in += datatypeSize;
 		totalSize -= datatypeSize;

monitoring/LimitViolationReporter.cpp

@@ -27,7 +27,7 @@ ReturnValue_t LimitViolationReporter::sendLimitViolationReport(const SerializeIF
 		return result;
 	}
 	size_t size = 0;
-	result = data->serialize(&dataTarget, &size, maxSize, true);
+	result = data->serialize(&dataTarget, &size, maxSize, SerializeIF::Endianness::BIG);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}

osal/host/QueueMapManager.cpp

@@ -17,6 +17,10 @@ QueueMapManager* QueueMapManager::instance() {
 
 ReturnValue_t QueueMapManager::addMessageQueue(
 		MessageQueueIF* queueToInsert, MessageQueueId_t* id) {
+	// Not thread-safe, but it is assumed all message queues are created
+	// at software initialization now. If this is to be made thread-safe in
+	// the future, it propably would be sufficient to lock the increment
+	// operation here
 	uint32_t currentId = queueCounter++;
 	auto returnPair = queueMap.emplace(currentId, queueToInsert);
 	if(not returnPair.second) {
@@ -28,7 +32,6 @@ ReturnValue_t QueueMapManager::addMessageQueue(
 	if (id != nullptr) {
 		*id = currentId;
 	}
-	mapLock = MutexFactory::instance()->createMutex();
 	return HasReturnvaluesIF::RETURN_OK;
 }
 

osal/host/QueueMapManager.h

@@ -36,7 +36,7 @@ public:
 private:
 	//! External instantiation is forbidden.
 	QueueMapManager();
-	std::atomic<uint32_t> queueCounter = 1;
+	uint32_t queueCounter = 1;
 	MutexIF* mapLock;
 	QueueMap queueMap;
 	static QueueMapManager* mqManagerInstance;

osal/linux/MessageQueue.cpp

@@ -62,22 +62,27 @@ ReturnValue_t MessageQueue::handleError(mq_attr* attributes,
 		// Just an additional helpful printout :-)
 		if(std::ifstream("/proc/sys/fs/mqueue/msg_max",std::ios::in) >>
 				defaultMqMaxMsg and defaultMqMaxMsg < messageDepth) {
-			// See: https://www.man7.org/linux/man-pages/man3/mq_open.3.html
+			/*
-			// This happens if the msg_max value is not large enough
+			See: https://www.man7.org/linux/man-pages/man3/mq_open.3.html
-			// It is ignored if the executable is run in privileged mode.
+			This happens if the msg_max value is not large enough
-			// Run the unlockRealtime script or grant the mode manually by using:
+			It is ignored if the executable is run in privileged mode.
-			// sudo setcap 'CAP_SYS_RESOURCE=+ep' <pathToBinary>
+		    Run the unlockRealtime script or grant the mode manually by using:
+			sudo setcap 'CAP_SYS_RESOURCE=+ep' <pathToBinary>
 
-			// Persistent solution for session:
+			Persistent solution for session:
-			// echo <newMsgMax> | sudo tee /proc/sys/fs/mqueue/msg_max
+			echo <newMsgMax> | sudo tee /proc/sys/fs/mqueue/msg_max
 
-			// Permanent solution:
+			Permanent solution:
-			// sudo nano /etc/sysctl.conf
+			sudo nano /etc/sysctl.conf
-			// Append at end: fs/mqueue/msg_max = <newMsgMaxLen>
+			Append at end: fs/mqueue/msg_max = <newMsgMaxLen>
-			// Apply changes with: sudo sysctl -p
+			Apply changes with: sudo sysctl -p
+			*/
 			sif::error << "MessageQueue::MessageQueue: Default MQ size "
 					<< defaultMqMaxMsg << " is too small for requested size "
 					<< messageDepth << std::endl;
+			sif::error << "This error can be fixed by setting the maximum "
+					"allowed message size higher!" << std::endl;
+
 		}
 		break;
 	}

osal/linux/PosixThread.cpp

@@ -149,8 +149,10 @@ void PosixThread::createTask(void* (*fnc_)(void*), void* arg_) {
 
 	status = pthread_attr_setstack(&attributes, stackPointer, stackSize);
 	if(status != 0){
-		sif::error << "Posix Thread attribute setStack failed with: " <<
+		sif::error << "PosixThread::createTask: pthread_attr_setstack "
-				strerror(status) << std::endl;
+				" failed with: " << strerror(status) <<  std::endl;
+		sif::error << "Make sure the specified stack size is valid and is "
+				"larger than the minimum allowed stack size." << std::endl;
 	}
 
 	status = pthread_attr_setinheritsched(&attributes, PTHREAD_EXPLICIT_SCHED);

osal/linux/TcUnixUdpPollingTask.cpp

@@ -0,0 +1,79 @@
+#include <framework/osal/linux/TcUnixUdpPollingTask.h>
+
+TcSocketPollingTask::TcSocketPollingTask(object_id_t objectId,
+		object_id_t tmtcUnixUdpBridge, size_t frameSize,
+		double timeoutSeconds): SystemObject(objectId),
+		tmtcBridgeId(tmtcUnixUdpBridge) {
+
+	if(frameSize > 0) {
+		this->frameSize = frameSize;
+	}
+	else {
+		this->frameSize = DEFAULT_MAX_FRAME_SIZE;
+	}
+
+	// Set up reception buffer with specified frame size.
+	// For now, it is assumed that only one frame is held in the buffer!
+	receptionBuffer.reserve(this->frameSize);
+	receptionBuffer.resize(this->frameSize);
+
+	if(timeoutSeconds == -1) {
+		receptionTimeout = DEFAULT_TIMEOUT;
+	}
+	else {
+		receptionTimeout = timevalOperations::toTimeval(timeoutSeconds);
+	}
+
+	// Set receive timeout.
+	int result = setsockopt(serverUdpSocket, SOL_SOCKET, SO_RCVTIMEO,
+			&receptionTimeout, sizeof(receptionTimeout));
+	if(result == -1) {
+		sif::error << "TcSocketPollingTask::TcSocketPollingTask: Setting receive"
+				"timeout failed with " << strerror(errno) << std::endl;
+		return;
+	}
+}
+
+TcSocketPollingTask::~TcSocketPollingTask() {
+}
+
+ReturnValue_t TcSocketPollingTask::performOperation(uint8_t opCode) {
+	// Poll for new data permanently. The call will block until the specified
+	// length of bytes has been received or a timeout occured.
+	while(1) {
+		//! Sender Address is cached here.
+		struct sockaddr_in senderAddress;
+		socklen_t senderSockLen = 0;
+		ssize_t bytesReceived = recvfrom(serverUdpSocket,
+				receptionBuffer.data(), frameSize, receptionFlags,
+				reinterpret_cast<sockaddr*>(&senderAddress), &senderSockLen);
+		if(bytesReceived < 0) {
+			//handle error
+			sif::error << "TcSocketPollingTask::performOperation: recvfrom "
+					"failed with " << strerror(errno) << std::endl;
+			continue;
+		}
+		sif::debug << "TcSocketPollingTask::performOperation: " << bytesReceived
+				<< " bytes received" << std::endl;
+
+		ReturnValue_t result = handleSuccessfullTcRead();
+		tmtcBridge->checkAndSetClientAddress(senderAddress);
+	}
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t TcSocketPollingTask::initialize() {
+	tmtcBridge = objectManager->get<TmTcUnixUdpBridge>(tmtcBridgeId);
+	if(tmtcBridge == nullptr) {
+		sif::error << "TcSocketPollingTask::TcSocketPollingTask: Invalid"
+				" TMTC bridge object!" << std::endl;
+		return ObjectManagerIF::CHILD_INIT_FAILED;
+	}
+
+	serverUdpSocket = tmtcBridge->serverSocket;
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t TcSocketPollingTask::handleSuccessfullTcRead() {
+	return HasReturnvaluesIF::RETURN_OK;
+}

osal/linux/TcUnixUdpPollingTask.h

@@ -0,0 +1,54 @@
+#ifndef FRAMEWORK_OSAL_LINUX_TCSOCKETPOLLINGTASK_H_
+#define FRAMEWORK_OSAL_LINUX_TCSOCKETPOLLINGTASK_H_
+#include <framework/objectmanager/SystemObject.h>
+#include <framework/osal/linux/TmTcUnixUdpBridge.h>
+#include <framework/tasks/ExecutableObjectIF.h>
+
+#include <sys/socket.h>
+#include <vector>
+
+/**
+ * @brief 	This class can be used to implement the polling of a Unix socket,
+ * 			using UDP for now.
+ * @details
+ * The task will be blocked while the specified number of bytes has not been
+ * received, so TC reception is handled inside a separate task.
+ * This class caches the IP address of the sender. It is assumed there
+ * is only one sender for now.
+ */
+class TcSocketPollingTask: public SystemObject,
+		public ExecutableObjectIF {
+	friend class TmTcUnixUdpBridge;
+public:
+	static constexpr size_t DEFAULT_MAX_FRAME_SIZE = 2048;
+	//! 0.5  default milliseconds timeout for now.
+	static constexpr timeval DEFAULT_TIMEOUT = {.tv_sec = 0, .tv_usec = 500};
+
+	TcSocketPollingTask(object_id_t objectId, object_id_t tmtcUnixUdpBridge,
+			size_t frameSize = 0, double timeoutSeconds = -1);
+	virtual~ TcSocketPollingTask();
+
+	virtual ReturnValue_t performOperation(uint8_t opCode) override;
+	virtual ReturnValue_t initialize() override;
+
+private:
+	//! TMTC bridge is cached.
+	object_id_t tmtcBridgeId = objects::NO_OBJECT;
+	TmTcUnixUdpBridge* tmtcBridge = nullptr;
+	//! Reception flags: https://linux.die.net/man/2/recvfrom.
+	int receptionFlags = 0;
+
+	//! Server socket, which is member of TMTC bridge and is assigned in
+	//! constructor
+	int serverUdpSocket = 0;
+
+	std::vector<uint8_t> receptionBuffer;
+
+	size_t frameSize = 0;
+	timeval receptionTimeout;
+
+	ReturnValue_t handleSuccessfullTcRead();
+
+};
+
+#endif /* FRAMEWORK_OSAL_LINUX_TCSOCKETPOLLINGTASK_H_ */

osal/linux/TmTcUnixUdpBridge.cpp

@@ -0,0 +1,140 @@
+#include <framework/osal/linux/TmTcUnixUdpBridge.h>
+#include <framework/serviceinterface/ServiceInterfaceStream.h>
+#include <errno.h>
+#include <framework/ipc/MutexHelper.h>
+
+TmTcUnixUdpBridge::TmTcUnixUdpBridge(object_id_t objectId,
+		object_id_t ccsdsPacketDistributor, uint16_t serverPort,
+		uint16_t clientPort):
+		TmTcBridge(objectId, ccsdsPacketDistributor) {
+	mutex = MutexFactory::instance()->createMutex();
+
+	uint16_t setServerPort = DEFAULT_UDP_SERVER_PORT;
+	if(serverPort != 0xFFFF) {
+		setServerPort = serverPort;
+	}
+
+	uint16_t setClientPort = DEFAULT_UDP_CLIENT_PORT;
+	if(clientPort != 0xFFFF) {
+		setClientPort = clientPort;
+	}
+
+	// Set up UDP socket: https://man7.org/linux/man-pages/man7/ip.7.html
+	serverSocket = socket(AF_INET, SOCK_DGRAM, 0);
+	if(socket < 0) {
+		sif::error << "TmTcUnixUdpBridge::TmTcUnixUdpBridge: Could not open"
+				" UDP socket!" << std::endl;
+		// check errno here.
+		handleSocketError();
+		return;
+	}
+
+	serverAddress.sin_family = AF_INET;
+	// Accept packets from any interface.
+	serverAddress.sin_addr.s_addr = htonl(INADDR_ANY);
+	serverAddress.sin_port = htons(setServerPort);
+	setsockopt(serverSocket, SOL_SOCKET, SO_REUSEADDR, &serverSocketOptions,
+			sizeof(serverSocketOptions));
+
+	serverSocketLen = sizeof(serverAddress);
+	int result = bind(serverSocket,
+			reinterpret_cast<struct sockaddr*>(&serverAddress),
+			serverSocketLen);
+	if(result == -1) {
+		sif::error << "TmTcUnixUdpBridge::TmTcUnixUdpBridge: Could not bind "
+				"local port " << setServerPort << " to server socket!"
+				<< std::endl;
+		// check errno here.
+		handleBindError();
+		return;
+	}
+}
+
+TmTcUnixUdpBridge::~TmTcUnixUdpBridge() {
+}
+
+ReturnValue_t TmTcUnixUdpBridge::sendTm(const uint8_t *data, size_t dataLen) {
+	int flags = 0;
+	ssize_t result = send(serverSocket, data, dataLen, flags);
+	if(result < 0) {
+		//handle error
+		sif::error << "TmTcUnixUdpBridge::sendTm: Send operation failed "
+				"with error " << strerror(errno) << std::endl;
+	}
+
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+void TmTcUnixUdpBridge::handleSocketError() {
+
+	// See: https://man7.org/linux/man-pages/man2/socket.2.html
+	switch(errno) {
+	case(EACCES):
+	case(EINVAL):
+	case(EMFILE):
+	case(ENFILE):
+	case(EAFNOSUPPORT):
+	case(ENOBUFS):
+	case(ENOMEM):
+	case(EPROTONOSUPPORT):
+		sif::error << "TmTcUnixBridge::TmTcUnixBridge: Socket creation failed"
+				<< " with " << strerror(errno) << std::endl;
+		break;
+	default:
+		sif::error << "TmTcUnixBridge::TmTcUnixBridge: Unknown error"
+				<< std::endl;
+		break;
+	}
+}
+
+void TmTcUnixUdpBridge::setTimeout(float timeoutSeconds) {
+}
+
+void TmTcUnixUdpBridge::checkAndSetClientAddress(sockaddr_in newAddress) {
+	MutexHelper lock(mutex, 10);
+	// Set new IP address if it has changed.
+	if(clientAddress.sin_addr.s_addr != newAddress.sin_addr.s_addr) {
+		clientAddress.sin_addr.s_addr = newAddress.sin_addr.s_addr;
+	}
+}
+
+void TmTcUnixUdpBridge::handleBindError() {
+	// See: https://man7.org/linux/man-pages/man2/bind.2.html
+	switch(errno) {
+	case(EACCES):
+		/*
+		 Ephermeral ports can be shown with following command:
+		 sysctl -A | grep ip_local_port_range
+		 */
+		sif::error << "TmTcUnixBridge::TmTcUnixBridge: Port access issue."
+				"Ports 1-1024 are reserved on UNIX systems and require root "
+				"rights while ephermeral ports should not be used as well."
+				<< std::endl;
+		break;
+	case(EADDRINUSE):
+	case(EBADF):
+	case(EINVAL):
+	case(ENOTSOCK):
+	case(EADDRNOTAVAIL):
+	case(EFAULT):
+	case(ELOOP):
+	case(ENAMETOOLONG):
+	case(ENOENT):
+	case(ENOMEM):
+	case(ENOTDIR):
+	case(EROFS):
+		sif::error << "TmTcUnixBridge::TmTcUnixBridge: Socket creation failed"
+					<< " with " << strerror(errno) << std::endl;
+		break;
+	default:
+		sif::error << "TmTcUnixBridge::TmTcUnixBridge: Unknown error"
+						<< std::endl;
+		break;
+	}
+}
+
+
+ReturnValue_t TmTcUnixUdpBridge::receiveTc(uint8_t **recvBuffer, size_t *size) {
+	// TC reception handled by separate polling task because it is blocking.
+	return HasReturnvaluesIF::RETURN_OK;
+}

osal/linux/TmTcUnixUdpBridge.h

@@ -0,0 +1,48 @@
+#ifndef FRAMEWORK_OSAL_LINUX_TMTCUNIXUDPBRIDGE_H_
+#define FRAMEWORK_OSAL_LINUX_TMTCUNIXUDPBRIDGE_H_
+
+#include <framework/tmtcservices/TmTcBridge.h>
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <netinet/udp.h>
+
+class TmTcUnixUdpBridge: public TmTcBridge {
+	friend class TcSocketPollingTask;
+public:
+	// The ports chosen here should not be used by any other process.
+	// List of used ports on Linux: /etc/services
+	static constexpr uint16_t DEFAULT_UDP_SERVER_PORT = 7301;
+	static constexpr uint16_t DEFAULT_UDP_CLIENT_PORT = 7302;
+
+	TmTcUnixUdpBridge(object_id_t objectId, object_id_t ccsdsPacketDistributor,
+			 uint16_t serverPort = 0xFFFF,uint16_t clientPort = 0xFFFF);
+	virtual~ TmTcUnixUdpBridge();
+
+	void setTimeout(float timeoutSeconds);
+	void checkAndSetClientAddress(sockaddr_in clientAddress);
+
+protected:
+	virtual ReturnValue_t receiveTc(uint8_t ** recvBuffer,
+			size_t * size) override;
+	virtual ReturnValue_t sendTm(const uint8_t * data, size_t dataLen) override;
+private:
+	int serverSocket = 0;
+	const int serverSocketOptions = 0;
+
+	struct sockaddr_in clientAddress;
+	socklen_t clientSocketLen = 0;
+
+	struct sockaddr_in serverAddress;
+	socklen_t serverSocketLen = 0;
+
+	//! Access to the client address is mutex protected as it is set
+	//! by another task.
+	MutexIF* mutex;
+
+	void handleSocketError();
+	void handleBindError();
+};
+
+
+
+#endif /* FRAMEWORK_OSAL_LINUX_TMTCUNIXUDPBRIDGE_H_ */

osal/rtems/CpuUsage.cpp

@@ -89,15 +89,15 @@ void CpuUsage::clear() {
 	threadData.clear();
 }
 
-ReturnValue_t CpuUsage::serialize(uint8_t** buffer, uint32_t* size,
+ReturnValue_t CpuUsage::serialize(uint8_t** buffer, size_t* size,
-		const uint32_t max_size, bool bigEndian) const {
+		size_t maxSize, Endianness streamEndianness) const {
-	ReturnValue_t result = SerializeAdapter<float>::serialize(
+	ReturnValue_t result = SerializeAdapter::serialize(
-			&timeSinceLastReset, buffer, size, max_size, bigEndian);
+			&timeSinceLastReset, buffer, size, maxSize, streamEndianness);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}
 	return SerialArrayListAdapter<ThreadData>::serialize(&threadData, buffer,
-			size, max_size, bigEndian);
+			size, maxSize, streamEndianness);
 }
 
 uint32_t CpuUsage::getSerializedSize() const {
@@ -109,37 +109,37 @@ uint32_t CpuUsage::getSerializedSize() const {
 	return size;
 }
 
-ReturnValue_t CpuUsage::deSerialize(const uint8_t** buffer, int32_t* size,
+ReturnValue_t CpuUsage::deSerialize(const uint8_t** buffer, size_t* size,
-		bool bigEndian) {
+		Endianness streamEndianness) {
-	ReturnValue_t result = SerializeAdapter<float>::deSerialize(
+	ReturnValue_t result = SerializeAdapter::deSerialize(
-			&timeSinceLastReset, buffer, size, bigEndian);
+			&timeSinceLastReset, buffer, size, streamEndianness);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}
 	return SerialArrayListAdapter<ThreadData>::deSerialize(&threadData, buffer,
-			size, bigEndian);
+			size, streamEndianness);
 }
 
-ReturnValue_t CpuUsage::ThreadData::serialize(uint8_t** buffer, uint32_t* size,
+ReturnValue_t CpuUsage::ThreadData::serialize(uint8_t** buffer, size_t* size,
-		const uint32_t max_size, bool bigEndian) const {
+		size_t maxSize, Endianness streamEndianness) const {
-	ReturnValue_t result = SerializeAdapter<uint32_t>::serialize(&id, buffer,
+	ReturnValue_t result = SerializeAdapter::serialize(&id, buffer,
-			size, max_size, bigEndian);
+			size, maxSize, streamEndianness);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}
-	if (*size + MAX_LENGTH_OF_THREAD_NAME > max_size) {
+	if (*size + MAX_LENGTH_OF_THREAD_NAME > maxSize) {
 		return BUFFER_TOO_SHORT;
 	}
 	memcpy(*buffer, name, MAX_LENGTH_OF_THREAD_NAME);
 	*size += MAX_LENGTH_OF_THREAD_NAME;
 	*buffer += MAX_LENGTH_OF_THREAD_NAME;
-	result = SerializeAdapter<float>::serialize(&timeRunning,
+	result = SerializeAdapter::serialize(&timeRunning,
-			buffer, size, max_size, bigEndian);
+			buffer, size, maxSize, streamEndianness);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}
-	result = SerializeAdapter<float>::serialize(&percentUsage,
+	result = SerializeAdapter::serialize(&percentUsage,
-			buffer, size, max_size, bigEndian);
+			buffer, size, maxSize, streamEndianness);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}
@@ -158,9 +158,9 @@ uint32_t CpuUsage::ThreadData::getSerializedSize() const {
 }
 
 ReturnValue_t CpuUsage::ThreadData::deSerialize(const uint8_t** buffer,
-		int32_t* size, bool bigEndian) {
+		int32_t* size, Endianness streamEndianness) {
-	ReturnValue_t result = SerializeAdapter<uint32_t>::deSerialize(&id, buffer,
+	ReturnValue_t result = SerializeAdapter::deSerialize(&id, buffer,
-			size, bigEndian);
+			size, streamEndianness);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}
@@ -169,13 +169,13 @@ ReturnValue_t CpuUsage::ThreadData::deSerialize(const uint8_t** buffer,
 	}
 	memcpy(name, *buffer, MAX_LENGTH_OF_THREAD_NAME);
 	*buffer -= MAX_LENGTH_OF_THREAD_NAME;
-	result = SerializeAdapter<float>::deSerialize(&timeRunning,
+	result = SerializeAdapter::deSerialize(&timeRunning,
-			buffer, size, bigEndian);
+			buffer, size, streamEndianness);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}
-	result = SerializeAdapter<float>::deSerialize(&percentUsage,
+	result = SerializeAdapter::deSerialize(&percentUsage,
-			buffer, size, bigEndian);
+			buffer, size, streamEndianness);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}

osal/rtems/CpuUsage.h

@@ -18,13 +18,13 @@ public:
 		float timeRunning;
 		float percentUsage;
 
-		virtual ReturnValue_t serialize(uint8_t** buffer, uint32_t* size,
+		virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
-				const uint32_t max_size, bool bigEndian) const;
+				size_t maxSize, Endianness streamEndianness) const override;
 
-		virtual uint32_t getSerializedSize() const;
+		virtual size_t getSerializedSize() const override;
 
-		virtual ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size,
+		virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
-				bool bigEndian);
+				Endianness streamEndianness) override;
 	};
 
 	CpuUsage();
@@ -41,13 +41,13 @@ public:
 
 	void clear();
 
-	virtual ReturnValue_t serialize(uint8_t** buffer, uint32_t* size,
+	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
-			const uint32_t max_size, bool bigEndian) const;
+			size_t maxSize, Endianness streamEndianness) const override;
 
-	virtual uint32_t getSerializedSize() const;
+	virtual size_t getSerializedSize() const override;
 
-	virtual ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size,
+	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
-			bool bigEndian);
+			Endianness streamEndianness) override;
 };
 
 #endif /* CPUUSAGE_H_ */

parameters/ParameterHelper.cpp

@@ -81,7 +81,7 @@ ReturnValue_t ParameterHelper::handleParameterMessage(CommandMessage *message) {
 
 ReturnValue_t ParameterHelper::sendParameter(MessageQueueId_t to, uint32_t id,
 		const ParameterWrapper* description) {
-	uint32_t serializedSize = description->getSerializedSize();
+	size_t serializedSize = description->getSerializedSize();
 
 	uint8_t *storeElement;
 	store_address_t address;
@@ -95,7 +95,7 @@ ReturnValue_t ParameterHelper::sendParameter(MessageQueueId_t to, uint32_t id,
 	size_t storeElementSize = 0;
 
 	result = description->serialize(&storeElement, &storeElementSize,
-			serializedSize, true);
+			serializedSize, SerializeIF::Endianness::BIG);
 
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		storage->deleteData(address);

parameters/ParameterWrapper.cpp

@@ -21,22 +21,22 @@ ParameterWrapper::~ParameterWrapper() {
 }
 
 ReturnValue_t ParameterWrapper::serialize(uint8_t **buffer, size_t *size,
-		const size_t max_size, bool bigEndian) const {
+		size_t maxSize, Endianness streamEndianness) const {
 	ReturnValue_t result;
 
-	result = SerializeAdapter<Type>::serialize(&type, buffer, size, max_size,
+	result = SerializeAdapter::serialize(&type, buffer, size, maxSize,
-			bigEndian);
+			streamEndianness);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}
 
-	result = SerializeAdapter<uint8_t>::serialize(&columns, buffer, size,
+	result = SerializeAdapter::serialize(&columns, buffer, size, maxSize,
-			max_size, bigEndian);
+			streamEndianness);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}
-	result = SerializeAdapter<uint8_t>::serialize(&rows, buffer, size, max_size,
+	result = SerializeAdapter::serialize(&rows, buffer, size, maxSize,
-			bigEndian);
+			streamEndianness);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}
@@ -47,28 +47,33 @@ ReturnValue_t ParameterWrapper::serialize(uint8_t** buffer, size_t* size,
 	}
 	switch (type) {
 	case Type::UINT8_T:
-		result = serializeData<uint8_t>(buffer, size, max_size, bigEndian);
+		result = serializeData<uint8_t>(buffer, size, maxSize,
+				streamEndianness);
 		break;
 	case Type::INT8_T:
-		result = serializeData<int8_t>(buffer, size, max_size, bigEndian);
+		result = serializeData<int8_t>(buffer, size, maxSize, streamEndianness);
 		break;
 	case Type::UINT16_T:
-		result = serializeData<uint16_t>(buffer, size, max_size, bigEndian);
+		result = serializeData<uint16_t>(buffer, size, maxSize,
+				streamEndianness);
 		break;
 	case Type::INT16_T:
-		result = serializeData<int16_t>(buffer, size, max_size, bigEndian);
+		result = serializeData<int16_t>(buffer, size, maxSize,
+				streamEndianness);
 		break;
 	case Type::UINT32_T:
-		result = serializeData<uint32_t>(buffer, size, max_size, bigEndian);
+		result = serializeData<uint32_t>(buffer, size, maxSize,
+				streamEndianness);
 		break;
 	case Type::INT32_T:
-		result = serializeData<int32_t>(buffer, size, max_size, bigEndian);
+		result = serializeData<int32_t>(buffer, size, maxSize,
+				streamEndianness);
 		break;
 	case Type::FLOAT:
-		result = serializeData<float>(buffer, size, max_size, bigEndian);
+		result = serializeData<float>(buffer, size, maxSize, streamEndianness);
 		break;
 	case Type::DOUBLE:
-		result = serializeData<double>(buffer, size, max_size, bigEndian);
+		result = serializeData<double>(buffer, size, maxSize, streamEndianness);
 		break;
 	default:
 		result = UNKNOW_DATATYPE;
@@ -89,13 +94,13 @@ size_t ParameterWrapper::getSerializedSize() const {
 
 template<typename T>
 ReturnValue_t ParameterWrapper::serializeData(uint8_t **buffer, size_t *size,
-		const size_t max_size, bool bigEndian) const {
+		size_t maxSize, Endianness streamEndianness) const {
 	const T *element = (const T*) readonlyData;
 	ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
 	uint16_t dataSize = columns * rows;
 	while (dataSize != 0) {
-		result = SerializeAdapter<T>::serialize(element, buffer, size, max_size,
+		result = SerializeAdapter::serialize(element, buffer, size, maxSize,
-				bigEndian);
+				streamEndianness);
 		if (result != HasReturnvaluesIF::RETURN_OK) {
 			return result;
 		}
@@ -123,9 +128,9 @@ ReturnValue_t ParameterWrapper::deSerializeData(uint8_t startingRow,
 				+ (((startingRow + fromRow) * columns) + startingColumn);
 
 		for (uint8_t fromColumn = 0; fromColumn < fromColumns; fromColumn++) {
-			result = SerializeAdapter<T>::deSerialize(
+			result = SerializeAdapter::deSerialize(
 					dataWithDataType + fromColumn, &fromAsStream, &streamSize,
-					true);
+					SerializeIF::Endianness::BIG);
 			if (result != HasReturnvaluesIF::RETURN_OK) {
 				return result;
 			}
@@ -136,13 +141,15 @@ ReturnValue_t ParameterWrapper::deSerializeData(uint8_t startingRow,
 
 }
 
+
 ReturnValue_t ParameterWrapper::deSerialize(const uint8_t **buffer,
-		size_t* size, bool bigEndian) {
+		size_t *size, Endianness streamEndianness) {
-	return deSerialize(buffer, size, bigEndian, 0);
+	return deSerialize(buffer, size, streamEndianness, 0);
 }
 
 ReturnValue_t ParameterWrapper::deSerialize(const uint8_t **buffer,
-		size_t* size, bool bigEndian, uint16_t startWritingAtIndex) {
+		size_t *size, Endianness streamEndianness,
+		uint16_t startWritingAtIndex) {
 	ParameterWrapper streamDescription;
 
 	ReturnValue_t result = streamDescription.set(*buffer, *size, buffer, size);
@@ -155,21 +162,19 @@ ReturnValue_t ParameterWrapper::deSerialize(const uint8_t** buffer,
 
 ReturnValue_t ParameterWrapper::set(const uint8_t *stream, size_t streamSize,
 		const uint8_t **remainingStream, size_t *remainingSize) {
-	// TODO: Replaced ssize_t for remainingSize and streamSize
+	ReturnValue_t result = SerializeAdapter::deSerialize(&type, &stream,
-	// is the logic here correct?
+			&streamSize, SerializeIF::Endianness::BIG);
-	ReturnValue_t result = SerializeAdapter<Type>::deSerialize(&type, &stream,
-			&streamSize, true);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}
 
-	result = SerializeAdapter<uint8_t>::deSerialize(&columns, &stream,
+	result = SerializeAdapter::deSerialize(&columns, &stream, &streamSize,
-			&streamSize, true);
+			SerializeIF::Endianness::BIG);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}
-	result = SerializeAdapter<uint8_t>::deSerialize(&rows, &stream, &streamSize,
+	result = SerializeAdapter::deSerialize(&rows, &stream, &streamSize,
-			true);
+			SerializeIF::Endianness::BIG);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}

parameters/ParameterWrapper.h

@@ -26,15 +26,15 @@ public:
 	virtual ~ParameterWrapper();
 
 	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
-			const size_t max_size, bool bigEndian) const;
+			size_t maxSize, Endianness streamEndianness) const override;
 
-	virtual size_t getSerializedSize() const;
+	virtual size_t getSerializedSize() const override;
 
 	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
-			bool bigEndian);
+			Endianness streamEndianness) override;
 
 	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
-			bool bigEndian, uint16_t startWritingAtIndex = 0);
+			Endianness streamEndianness, uint16_t startWritingAtIndex = 0);
 
 	template<typename T>
 	ReturnValue_t getElement(T *value, uint8_t row = 0, uint8_t column = 0) const {
@@ -54,7 +54,7 @@ public:
 			const uint8_t *streamWithtype = (const uint8_t *) readonlyData;
 			streamWithtype += (row * columns + column) * type.getSize();
 			int32_t size = type.getSize();
-			return SerializeAdapter<T>::deSerialize(value, &streamWithtype,
+			return SerializeAdapter::deSerialize(value, &streamWithtype,
 					&size, true);
 		} else {
 			const T *dataWithType = (const T *) readonlyData;
@@ -129,7 +129,7 @@ private:
 
 	template<typename T>
 	ReturnValue_t serializeData(uint8_t** buffer, size_t* size,
-			const size_t max_size, bool bigEndian) const;
+			size_t maxSize, Endianness streamEndianness) const;
 
 	template<typename T>
 	ReturnValue_t deSerializeData(uint8_t startingRow, uint8_t startingColumn,

power/Fuse.cpp

@@ -87,11 +87,11 @@ ReturnValue_t Fuse::check() {
 }
 
 ReturnValue_t Fuse::serialize(uint8_t** buffer, size_t* size,
-		const size_t max_size, bool bigEndian) const {
+		size_t maxSize, Endianness streamEndianness) const {
 	ReturnValue_t result = RETURN_FAILED;
 	for (DeviceList::const_iterator iter = devices.begin();
 			iter != devices.end(); iter++) {
-		result = (*iter)->serialize(buffer, size, max_size, bigEndian);
+		result = (*iter)->serialize(buffer, size, maxSize, streamEndianness);
 		if (result != RETURN_OK) {
 			return result;
 		}
@@ -99,8 +99,8 @@ ReturnValue_t Fuse::serialize(uint8_t** buffer, size_t* size,
 	return RETURN_OK;
 }
 
-uint32_t Fuse::getSerializedSize() const {
+size_t Fuse::getSerializedSize() const {
-	size_t size = 0;
+	uint32_t size = 0;
 	for (DeviceList::const_iterator iter = devices.begin();
 			iter != devices.end(); iter++) {
 		size += (*iter)->getSerializedSize();
@@ -109,11 +109,11 @@ uint32_t Fuse::getSerializedSize() const {
 }
 
 ReturnValue_t Fuse::deSerialize(const uint8_t** buffer, size_t* size,
-bool bigEndian) {
+        Endianness streamEndianness) {
 	ReturnValue_t result = RETURN_FAILED;
 	for (DeviceList::iterator iter = devices.begin(); iter != devices.end();
 			iter++) {
-		result = (*iter)->deSerialize(buffer, size, bigEndian);
+		result = (*iter)->deSerialize(buffer, size, streamEndianness);
 		if (result != RETURN_OK) {
 			return result;
 		}

power/Fuse.h

@@ -19,7 +19,8 @@ void setStaticFrameworkObjectIds();
 class Fuse: public SystemObject,
 		public HasHealthIF,
 		public HasReturnvaluesIF,
-		public ReceivesParameterMessagesIF {
+		public ReceivesParameterMessagesIF,
+		public SerializeIF {
 	friend void (Factory::setStaticFrameworkObjectIds)();
 private:
 	static constexpr float RESIDUAL_POWER = 0.005 * 28.5; //!< This is the upper limit of residual power lost by fuses and switches. Worst case is Fuse and one of two switches on. See PCDU ICD 1.9 p29 bottom
@@ -50,11 +51,11 @@ public:
 	uint8_t getFuseId() const;
 	ReturnValue_t initialize();
 	DeviceList devices;
-	ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+	ReturnValue_t serialize(uint8_t **buffer, size_t *size, size_t maxSize,
-			const size_t max_size, bool bigEndian) const;
+			SerializeIF::Endianness streamEndianness) const override;
-	uint32_t getSerializedSize() const;
+	size_t getSerializedSize() const override;
 	ReturnValue_t deSerialize(const uint8_t **buffer, size_t *size,
-				bool bigEndian);
+			SerializeIF::Endianness streamEndianness) override;
 	void setAllMonitorsToUnchecked();
 	ReturnValue_t performOperation(uint8_t opCode);
 	MessageQueueId_t getCommandQueue() const;

power/PowerComponent.cpp

@@ -18,14 +18,14 @@ PowerComponent::PowerComponent(object_id_t setId, uint8_t moduleId, float min, f
 }
 
 ReturnValue_t PowerComponent::serialize(uint8_t** buffer, size_t* size,
-		const size_t max_size, bool bigEndian) const {
+		size_t maxSize, Endianness streamEndianness) const {
-	ReturnValue_t result = SerializeAdapter<float>::serialize(&min, buffer,
+	ReturnValue_t result = SerializeAdapter::serialize(&min, buffer,
-			size, max_size, bigEndian);
+			size, maxSize, streamEndianness);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}
-	return SerializeAdapter<float>::serialize(&max, buffer, size, max_size,
+	return SerializeAdapter::serialize(&max, buffer, size, maxSize,
-			bigEndian);
+			streamEndianness);
 }
 
 size_t PowerComponent::getSerializedSize() const {
@@ -57,13 +57,13 @@ float PowerComponent::getMax() {
 }
 
 ReturnValue_t PowerComponent::deSerialize(const uint8_t** buffer, size_t* size,
-			bool bigEndian) {
+        Endianness streamEndianness) {
-	ReturnValue_t result = SerializeAdapter<float>::deSerialize(&min, buffer,
+	ReturnValue_t result = SerializeAdapter::deSerialize(&min, buffer,
-			size, bigEndian);
+			size, streamEndianness);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}
-	return SerializeAdapter<float>::deSerialize(&max, buffer, size, bigEndian);
+	return SerializeAdapter::deSerialize(&max, buffer, size, streamEndianness);
 }
 
 ReturnValue_t PowerComponent::getParameter(uint8_t domainId,

power/PowerComponent.h

@@ -20,12 +20,12 @@ public:
 	float getMax();
 
 	ReturnValue_t serialize(uint8_t** buffer, size_t* size,
-			const size_t max_size, bool bigEndian) const;
+			size_t maxSize, Endianness streamEndianness) const override;
 
-	size_t getSerializedSize() const;
+	size_t getSerializedSize() const override;
 
 	ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
-			bool bigEndian);
+			Endianness streamEndianness) override;
 
 	ReturnValue_t getParameter(uint8_t domainId, uint16_t parameterId,
 				ParameterWrapper *parameterWrapper,

returnvalues/FwClassIds.h

@@ -64,6 +64,7 @@ enum {
 	LOCAL_POOL_OWNER_IF, //LPIF 58
 	POOL_VARIABLE_IF, //PVA 59
 	HOUSEKEEPING_MANAGER, //HKM 60
+	PUS_PARSER, //PUSP 61
 	FW_CLASS_ID_COUNT //is actually count + 1 !
 
 };

returnvalues/HasReturnvaluesIF.h

@@ -12,8 +12,7 @@ typedef uint16_t ReturnValue_t;
 class HasReturnvaluesIF {
 public:
 	static const ReturnValue_t RETURN_OK = 0;
-	//! This will be the all-ones value irrespective of used unsigned datatype.
+	static const ReturnValue_t RETURN_FAILED = 1;
-	static const ReturnValue_t RETURN_FAILED = -1;
 	virtual ~HasReturnvaluesIF() {}
 
 	static ReturnValue_t makeReturnCode(uint8_t interfaceId, uint8_t number) {
@@ -21,4 +20,4 @@ public:
 	}
 };
 
-#endif /* HASRETURNVALUESIF_H_ */
+#endif /* FRAMEWORK_RETURNVALUES_HASRETURNVALUESIF_H_ */

serialize/EndianConverter.h

@@ -0,0 +1,124 @@
+#ifndef ENDIANSWAPPER_H_
+#define ENDIANSWAPPER_H_
+
+#include <framework/osal/Endiness.h>
+#include <cstring>
+#include <iostream>
+
+/**
+ * Helper class to convert variables or bitstreams between machine
+ * endian and either big or little endian.
+ * Machine endian is the endianness used by the machine running the
+ * program and is one of big or little endian. As this is portable
+ * code, it is not known at coding time which it is. At compile time
+ * it is however, which is why this is implemented using compiler
+ * macros and translates to a copy operation at runtime.
+ *
+ * This changes the layout of multi-byte variables in the machine's
+ * memory. In most cases, you should not need to use this class.
+ * Probably what you are looking for is the SerializeAdapter.
+ * If you still decide you need this class, please read and understand
+ * the code first.
+ *
+ * The order of the individual bytes of the multi-byte variable is
+ * reversed, the byte at the highest address is moved to the lowest
+ * address and vice versa, same for the bytes in between.
+ *
+ * Note that the conversion is also its inversion, that is converting
+ * from machine to a specified endianness is the same operation as
+ * converting from specified to machine (I looked it up, mathematicians
+ * would call it an involution):
+ *
+ * X == convertBigEndian(convertBigEndian(X))
+ *
+ * Thus, there is only one function supplied to do the conversion.
+ */
+class EndianConverter {
+private:
+	EndianConverter() {};
+public:
+	/**
+	 * Convert a typed variable between big endian and machine endian.
+	 * Intended for plain old datatypes.
+	 */
+	template<typename T>
+	static T convertBigEndian(T in) {
+#ifndef BYTE_ORDER_SYSTEM
+#error BYTE_ORDER_SYSTEM not defined
+#elif BYTE_ORDER_SYSTEM == LITTLE_ENDIAN
+		T tmp;
+		uint8_t *pointerOut = (uint8_t*) &tmp;
+		uint8_t *pointerIn = (uint8_t*) &in;
+		for (size_t count = 0; count < sizeof(T); count++) {
+			pointerOut[sizeof(T) - count - 1] = pointerIn[count];
+		}
+		return tmp;
+#elif BYTE_ORDER_SYSTEM == BIG_ENDIAN
+		return in;
+#else
+#error Unknown Byte Order
+#endif
+	}
+
+	/**
+	 * convert a bytestream representing a single variable between big endian
+	 * and machine endian.
+	 */
+	static void convertBigEndian(uint8_t *out, const uint8_t *in,
+			size_t size) {
+#ifndef BYTE_ORDER_SYSTEM
+#error BYTE_ORDER_SYSTEM not defined
+#elif BYTE_ORDER_SYSTEM == LITTLE_ENDIAN
+		for (size_t count = 0; count < size; count++) {
+			out[size - count - 1] = in[count];
+		}
+		return;
+#elif BYTE_ORDER_SYSTEM == BIG_ENDIAN
+		memcpy(out, in, size);
+		return;
+#endif
+	}
+
+	/**
+	 * Convert a typed variable between little endian and machine endian.
+	 * Intended for plain old datatypes.
+	 */
+	template<typename T>
+	static T convertLittleEndian(T in) {
+#ifndef BYTE_ORDER_SYSTEM
+	#error BYTE_ORDER_SYSTEM not defined
+	#elif BYTE_ORDER_SYSTEM == BIG_ENDIAN
+			T tmp;
+			uint8_t *pointerOut = (uint8_t *) &tmp;
+			uint8_t *pointerIn = (uint8_t *) &in;
+			for (size_t count = 0; count < sizeof(T); count++) {
+				pointerOut[sizeof(T) - count - 1] = pointerIn[count];
+			}
+			return tmp;
+	#elif BYTE_ORDER_SYSTEM == LITTLE_ENDIAN
+		return in;
+#else
+	#error Unknown Byte Order
+	#endif
+	}
+	/**
+	 * convert a bytestream representing a single variable between little endian
+	 * and machine endian.
+	 */
+	static void convertLittleEndian(uint8_t *out, const uint8_t *in,
+			size_t size) {
+#ifndef BYTE_ORDER_SYSTEM
+	#error BYTE_ORDER_SYSTEM not defined
+	#elif BYTE_ORDER_SYSTEM == BIG_ENDIAN
+			for (size_t count = 0; count < size; count++) {
+				out[size - count - 1] = in[count];
+			}
+			return;
+	#elif BYTE_ORDER_SYSTEM == LITTLE_ENDIAN
+		memcpy(out, in, size);
+		return;
+#endif
+	}
+};
+
+#endif /* ENDIANSWAPPER_H_ */

serialize/EndianSwapper.h

@@ -1,90 +0,0 @@
-#ifndef ENDIANSWAPPER_H_
-#define ENDIANSWAPPER_H_
-
-#include <framework/osal/Endiness.h>
-#include <cstring>
-#include <iostream>
-
-/**
- * @brief Can be used to swap endianness of data
- *        into big endian
- */
-class EndianSwapper {
-private:
-	EndianSwapper() {};
-public:
-	/**
-	 * Swap the endianness of a variable with arbitrary type
-	 * @tparam T Type of variable
-	 * @param in variable
-	 * @return Variable with swapped endianness
-	 */
-	template<typename T>
-	static T swap(T in) {
-#ifndef BYTE_ORDER_SYSTEM
-#error BYTE_ORDER_SYSTEM not defined
-#elif BYTE_ORDER_SYSTEM == LITTLE_ENDIAN
-		T tmp;
-		uint8_t *pointerOut = (uint8_t *) &tmp;
-		uint8_t *pointerIn = (uint8_t *) &in;
-		for (uint8_t count = 0; count < sizeof(T); count++) {
-			pointerOut[sizeof(T) - count - 1] = pointerIn[count];
-		}
-		return tmp;
-#elif BYTE_ORDER_SYSTEM == BIG_ENDIAN
-		return in;
-#else
-#error Unknown Byte Order
-#endif
-	}
-
-	/**
-	 * Swap the endianness of a buffer.
-	 * @param out
-	 * @param in
-	 * @param size
-	 */
-	static void swap(uint8_t* out, const uint8_t* in, size_t size) {
-#ifndef BYTE_ORDER_SYSTEM
-#error BYTE_ORDER_SYSTEM not defined
-#elif BYTE_ORDER_SYSTEM == LITTLE_ENDIAN
-		for (uint8_t count = 0; count < size; count++) {
-			out[size - count - 1] = in[count];
-		}
-		return;
-#elif BYTE_ORDER_SYSTEM == BIG_ENDIAN
-		memcpy(out, in, size);
-		return;
-#endif
-	}
-
-	/**
-	 * Swap endianness of buffer entries
-	 * Template argument specifies buffer type. The number of entries
-	 * (not the buffer size!) must be supplied
-	 * @param out
-	 * @param in
-	 * @param size Number of buffer entries (not size of buffer in bytes!)
-	 */
-	template<typename T>
-	static void swap(T * out, const T * in, uint32_t entries) {
-#ifndef BYTE_ORDER_SYSTEM
-#error BYTE_ORDER_SYSTEM not defined
-#elif BYTE_ORDER_SYSTEM == LITTLE_ENDIAN
-		const uint8_t * in_buffer = reinterpret_cast<const uint8_t *>(in);
-		uint8_t * out_buffer = reinterpret_cast<uint8_t *>(out);
-		for (uint8_t count = 0; count < entries; count++) {
-			for(uint8_t i = 0; i < sizeof(T);i++) {
-				out_buffer[sizeof(T)* (count + 1) - i - 1] =
-						in_buffer[count * sizeof(T) + i];
-			}
-		}
-		return;
-#elif BYTE_ORDER_SYSTEM == BIG_ENDIAN
-		memcpy(out, in, size*sizeof(T));
-		return;
-#endif
-	}
-};
-
-#endif /* ENDIANSWAPPER_H_ */

serialize/SerialArrayListAdapter.h

@@ -22,26 +22,24 @@ public:
 	}
 
 	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
-			const size_t max_size, bool bigEndian) const  override {
+			size_t maxSize, Endianness streamEndianness) const {
-		return serialize(adaptee, buffer, size, max_size, bigEndian);
+		return serialize(adaptee, buffer, size, maxSize, streamEndianness);
 	}
 
-	static ReturnValue_t serialize(const ArrayList<T, count_t>* list,
+	static ReturnValue_t serialize(const ArrayList<T, count_t>* list, uint8_t** buffer, size_t* size,
-			uint8_t** buffer, size_t* size, const size_t max_size,
+			size_t maxSize, Endianness streamEndianness) {
-			bool bigEndian) {
+		ReturnValue_t result = SerializeAdapter::serialize(&list->size,
-		// Serialize length field first
+				buffer, size, maxSize, streamEndianness);
-		ReturnValue_t result = SerializeAdapter<count_t>::serialize(&list->size,
-				buffer, size, max_size, bigEndian);
 		count_t i = 0;
 		while ((result == HasReturnvaluesIF::RETURN_OK) && (i < list->size)) {
-			result = SerializeAdapter<T>::serialize(&list->entries[i], buffer, size,
+			result = SerializeAdapter::serialize(&list->entries[i], buffer, size,
-					max_size, bigEndian);
+					maxSize, streamEndianness);
 			++i;
 		}
 		return result;
 	}
 
-	virtual size_t getSerializedSize() const override {
+	virtual size_t getSerializedSize() const {
 		return getSerializedSize(adaptee);
 	}
 
@@ -50,34 +48,31 @@ public:
 		count_t i = 0;
 
 		for (i = 0; i < list->size; ++i) {
-			printSize += SerializeAdapter<T>::getSerializedSize(&list->entries[i]);
+			printSize += SerializeAdapter::getSerializedSize(&list->entries[i]);
 		}
 
 		return printSize;
 	}
 
 	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
-			bool bigEndian) override {
+			Endianness streamEndianness) {
-		return deSerialize(adaptee, buffer, size, bigEndian);
+		return deSerialize(adaptee, buffer, size, streamEndianness);
 	}
 
-	static ReturnValue_t deSerialize(ArrayList<T, count_t>* list,
+	static ReturnValue_t deSerialize(ArrayList<T, count_t>* list, const uint8_t** buffer, size_t* size,
-			const uint8_t** buffer, size_t* size, bool bigEndian) {
+			Endianness streamEndianness) {
 		count_t tempSize = 0;
-		ReturnValue_t result = SerializeAdapter<count_t>::deSerialize(&tempSize,
+		ReturnValue_t result = SerializeAdapter::deSerialize(&tempSize,
-				buffer, size, bigEndian);
+				buffer, size, streamEndianness);
-		if(result != HasReturnvaluesIF::RETURN_OK) {
-			return result;
-		}
 		if (tempSize > list->maxSize()) {
 			return SerializeIF::TOO_MANY_ELEMENTS;
 		}
 		list->size = tempSize;
 		count_t i = 0;
 		while ((result == HasReturnvaluesIF::RETURN_OK) && (i < list->size)) {
-			result = SerializeAdapter<T>::deSerialize(
+			result = SerializeAdapter::deSerialize(
 					&list->front()[i], buffer, size,
-					bigEndian);
+					streamEndianness);
 			++i;
 		}
 		return result;

serialize/SerialBufferAdapter.cpp

@@ -20,54 +20,54 @@ template<typename count_t>
 SerialBufferAdapter<count_t>::~SerialBufferAdapter() {
 }
 
-template<typename count_t>
+template<typename T>
-ReturnValue_t SerialBufferAdapter<count_t>::serialize(uint8_t** buffer_,
+ReturnValue_t SerialBufferAdapter<T>::serialize(uint8_t** buffer, size_t* size,
-		size_t* size_, const size_t max_size, bool bigEndian) const {
+		size_t maxSize, Endianness streamEndianness) const {
 	uint32_t serializedLength = bufferLength;
 	if (serializeLength) {
-		serializedLength += AutoSerializeAdapter::getSerializedSize(
+		serializedLength += SerializeAdapter::getSerializedSize(
 				&bufferLength);
 	}
-	if (*size_ + serializedLength > max_size) {
+	if (*size + serializedLength > maxSize) {
 		return BUFFER_TOO_SHORT;
 	} else {
 		if (serializeLength) {
-			AutoSerializeAdapter::serialize(&bufferLength, buffer_, size_,
+			SerializeAdapter::serialize(&bufferLength, buffer, size,
-					max_size, bigEndian);
+					maxSize, streamEndianness);
 		}
 		if (constBuffer != nullptr) {
-			memcpy(*buffer_, this->constBuffer, bufferLength);
+			memcpy(*buffer, this->constBuffer, bufferLength);
 		}
 		else if (buffer != nullptr) {
 			// This will propably be never reached, constBuffer should always be
 			// set if non-const buffer is set.
-			memcpy(*buffer_, this->buffer, bufferLength);
+			memcpy(*buffer, this->buffer, bufferLength);
 		}
 		else {
 			return HasReturnvaluesIF::RETURN_FAILED;
 		}
-		*size_ += bufferLength;
+		*size += bufferLength;
-		(*buffer_) += bufferLength;
+		(*buffer) += bufferLength;
 		return HasReturnvaluesIF::RETURN_OK;
 	}
 }
 
-template<typename count_t>
+template<typename T>
-size_t SerialBufferAdapter<count_t>::getSerializedSize() const {
+size_t SerialBufferAdapter<T>::getSerializedSize() const {
 	if (serializeLength) {
-		return bufferLength + AutoSerializeAdapter::getSerializedSize(&bufferLength);
+		return bufferLength + SerializeAdapter::getSerializedSize(&bufferLength);
 	} else {
 		return bufferLength;
 	}
 }
 
-template<typename count_t>
+template<typename T>
-ReturnValue_t SerialBufferAdapter<count_t>::deSerialize(const uint8_t** buffer,
+ReturnValue_t SerialBufferAdapter<T>::deSerialize(const uint8_t** buffer,
-		size_t* size, bool bigEndian) {
+		size_t* size, Endianness streamEndianness) {
 	//TODO Ignores Endian flag!
-	if (buffer != nullptr) {
+	if (buffer != NULL) {
 		if(serializeLength){
-			count_t serializedSize = AutoSerializeAdapter::getSerializedSize(
+			T serializedSize = SerializeAdapter::getSerializedSize(
 					&bufferLength);
 			if(bufferLength + serializedSize <= *size) {
 				*buffer +=  serializedSize;

serialize/SerialBufferAdapter.h

@@ -45,10 +45,10 @@ public:
 
     virtual ~SerialBufferAdapter();
 
-	virtual ReturnValue_t serialize(uint8_t** buffer_, size_t* size,
+    virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
-			const size_t max_size, bool bigEndian) const override;
+            size_t maxSize, Endianness streamEndianness) const override;
 
-	virtual size_t getSerializedSize() const;
+    virtual size_t getSerializedSize() const override;
 
     /**
      * @brief This function deserializes a buffer into the member buffer.
@@ -63,7 +63,7 @@ public:
      * @return
      */
     virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
-			bool bigEndian) override;
+            Endianness streamEndianness) override;
 
     uint8_t * getBuffer();
     const uint8_t * getConstBuffer();

serialize/SerialFixedArrayListAdapter.h

@@ -39,32 +39,25 @@ public:
 	 */
 	template<typename... Args>
 	SerialFixedArrayListAdapter(Args... args) :
-	FixedArrayList<BUFFER_TYPE, MAX_SIZE, count_t>(std::forward<Args>(args)...)
+	        FixedArrayList<BUFFER_TYPE, MAX_SIZE, count_t>(
-	{}
+	        std::forward<Args>(args)...){}
 
-	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+    ReturnValue_t serialize(uint8_t** buffer, size_t* size,
-			const size_t max_size, bool bigEndian) const  override {
+            size_t maxSize, Endianness streamEndianness) const {
         return SerialArrayListAdapter<BUFFER_TYPE, count_t>::serialize(this,
-				buffer, size, max_size, bigEndian);
+                buffer, size, maxSize, streamEndianness);
     }
 
     size_t getSerializedSize() const {
-		return SerialArrayListAdapter<BUFFER_TYPE, count_t>::
+        return SerialArrayListAdapter<BUFFER_TYPE, count_t>::getSerializedSize(this);
-				getSerializedSize(this);
     }
 
-	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
+    ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
-			bool bigEndian) override {
+            Endianness streamEndianness) {
         return SerialArrayListAdapter<BUFFER_TYPE, count_t>::deSerialize(this,
-				buffer, size, bigEndian);
+                buffer, size, streamEndianness);
     }
 
-	void swapArrayListEndianness() {
-		SerialArrayListAdapter<BUFFER_TYPE, count_t>::
-				swapArrayListEndianness(this);
-	}
 };
 
-
-
 #endif /* SERIALFIXEDARRAYLISTADAPTER_H_ */

serialize/SerialLinkedListAdapter.h

@@ -67,44 +67,32 @@ public:
 			SinglyLinkedList<T>(), printCount(printCount) {
 	}
 
-	/**
-	 * Serialize object implementing this adapter into the supplied buffer
-	 * and calculate the serialized size
-	 * @param buffer [out] Object is serialized into this buffer.
-	 *    Note that the buffer pointer *buffer is incremented automatically
-	 *    inside the respective serialize functions
-	 * @param size [out] Calculated serialized size. Don't forget to set to 0.
-	 * @param max_size
-	 * @param bigEndian Specify endianness
-	 * @return
-	 */
 	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
-			const size_t max_size, bool bigEndian) const override{
+			size_t maxSize, Endianness streamEndianness) const override {
 		if (printCount) {
 			count_t mySize = SinglyLinkedList<T>::getSize();
-			ReturnValue_t result = SerializeAdapter<count_t>::serialize(&mySize,
+			ReturnValue_t result = SerializeAdapter::serialize(&mySize,
-					buffer, size, max_size, bigEndian);
+					buffer, size, maxSize, streamEndianness);
 			if (result != HasReturnvaluesIF::RETURN_OK) {
 				return result;
 			}
 		}
-		return serialize(SinglyLinkedList<T>::start, buffer, size, max_size,
+		return serialize(SinglyLinkedList<T>::start, buffer, size, maxSize,
-				bigEndian);
+				streamEndianness);
 	}
 
 	static ReturnValue_t serialize(const LinkedElement<T>* element,
-			uint8_t** buffer, size_t* size, const size_t max_size,
+			uint8_t** buffer, size_t* size, size_t maxSize,
-			bool bigEndian) {
+			Endianness streamEndianness) {
 		ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
 		while ((result == HasReturnvaluesIF::RETURN_OK) && (element != NULL)) {
-			result = element->value->serialize(buffer, size, max_size,
+			result = element->value->serialize(buffer, size, maxSize,
-					bigEndian);
+					streamEndianness);
 			element = element->getNext();
 		}
 		return result;
 	}
 
-
 	virtual size_t getSerializedSize() const override {
 		if (printCount) {
 			return SerialLinkedListAdapter<T>::getSerializedSize()
@@ -114,8 +102,8 @@ public:
 		}
 	}
 
-	static uint32_t getSerializedSize(const LinkedElement<T> *element) {
+	static size_t getSerializedSize(const LinkedElement<T> *element) {
-		uint32_t size = 0;
+		size_t size = 0;
 		while (element != NULL) {
 			size += element->value->getSerializedSize();
 			element = element->getNext();
@@ -124,24 +112,16 @@ public:
 	}
 
 
-	/**
-	 * Deserialize supplied buffer with supplied size into object
-	 * implementing this adapter.
-	 * @param buffer
-	 * @param size Decremented in respective deSerialize functions automatically
-	 * @param bigEndian Specify endianness
-	 * @return
-	 */
 	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
-			bool bigEndian) override {
+			Endianness streamEndianness) override {
-		return deSerialize(SinglyLinkedList<T>::start, buffer, size, bigEndian);
+		return deSerialize(SinglyLinkedList<T>::start, buffer, size, streamEndianness);
 	}
 
 	static ReturnValue_t deSerialize(LinkedElement<T>* element,
-			const uint8_t** buffer, size_t* size, bool bigEndian) {
+			const uint8_t** buffer, size_t* size, Endianness streamEndianness) {
 		ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
 		while ((result == HasReturnvaluesIF::RETURN_OK) && (element != NULL)) {
-			result = element->value->deSerialize(buffer, size, bigEndian);
+			result = element->value->deSerialize(buffer, size, streamEndianness);
 			element = element->getNext();
 		}
 		return result;

serialize/SerializeAdapter.h

@@ -1,9 +1,10 @@
 #ifndef SERIALIZEADAPTER_H_
 #define SERIALIZEADAPTER_H_
 
+#include <framework/container/IsDerivedFrom.h>
 #include <framework/returnvalues/HasReturnvaluesIF.h>
+#include <framework/serialize/EndianConverter.h>
 #include <framework/serialize/SerializeIF.h>
-#include <framework/serialize/SerializeAdapterInternal.h>
 #include <type_traits>
 
  /**
@@ -62,61 +63,113 @@
  * @ingroup serialize
  */
 
-// No type specification necessary here.
+class SerializeAdapter {
-class AutoSerializeAdapter {
 public:
-    /**
-     * Serialize object into buffer.
-     * @tparam T Type of object.
-     * @param object Object to serialize
-     * @param buffer
-     * Serialize into this buffer, pointer to pointer has to be passed,
-     * *buffer will be incremented automatically.
-     * @param size [out]
-     * Update passed size value, will be incremented by serialized size
-     * @param max_size
-     * Maximum size for range checking
-     * @param bigEndian
-     * Set to true if host-to-network conversion or vice-versa is needed
-     * @return
-     */
 	template<typename T>
 	static ReturnValue_t serialize(const T *object, uint8_t **buffer,
-			size_t* size, const size_t max_size, bool bigEndian) {
+			size_t *size, size_t maxSize, SerializeIF::Endianness streamEndianness) {
-		SerializeAdapter_<T, IsDerivedFrom<T, SerializeIF>::Is> adapter;
+		InternalSerializeAdapter<T, IsDerivedFrom<T, SerializeIF>::Is> adapter;
-		return adapter.serialize(object, buffer, size, max_size, bigEndian);
+		return adapter.serialize(object, buffer, size, maxSize,
+				streamEndianness);
 	}
 	template<typename T>
-	static size_t getSerializedSize(const T* object) {
+	static uint32_t getSerializedSize(const T *object) {
-		SerializeAdapter_<T, IsDerivedFrom<T, SerializeIF>::Is> adapter;
+		InternalSerializeAdapter<T, IsDerivedFrom<T, SerializeIF>::Is> adapter;
 		return adapter.getSerializedSize(object);
 	}
 	template<typename T>
 	static ReturnValue_t deSerialize(T *object, const uint8_t **buffer,
-			size_t* size, bool bigEndian) {
+			size_t *size, SerializeIF::Endianness streamEndianness) {
-		SerializeAdapter_<T, IsDerivedFrom<T, SerializeIF>::Is> adapter;
+		InternalSerializeAdapter<T, IsDerivedFrom<T, SerializeIF>::Is> adapter;
-		return adapter.deSerialize(object, buffer, size, bigEndian);
+		return adapter.deSerialize(object, buffer, size, streamEndianness);
 	}
+private:
+	template<typename T, int>
+	class InternalSerializeAdapter {
+	public:
+		static ReturnValue_t serialize(const T *object, uint8_t **buffer,
+				size_t *size, size_t max_size, SerializeIF::Endianness streamEndianness) {
+			size_t ignoredSize = 0;
+			if (size == NULL) {
+				size = &ignoredSize;
+			}
+			//TODO check integer overflow of *size
+			if (sizeof(T) + *size <= max_size) {
+				T tmp;
+				switch (streamEndianness) {
+				case SerializeIF::Endianness::BIG:
+					tmp = EndianConverter::convertBigEndian<T>(*object);
+					break;
+				case SerializeIF::Endianness::LITTLE:
+					tmp = EndianConverter::convertLittleEndian<T>(*object);
+					break;
+				default:
+				case SerializeIF::Endianness::MACHINE:
+					tmp = *object;
+					break;
+				}
+				memcpy(*buffer, &tmp, sizeof(T));
+				*size += sizeof(T);
+				(*buffer) += sizeof(T);
+				return HasReturnvaluesIF::RETURN_OK;
+			} else {
+				return SerializeIF::BUFFER_TOO_SHORT;
+			}
+		}
+
+		ReturnValue_t deSerialize(T *object, const uint8_t **buffer,
+				size_t *size, SerializeIF::Endianness streamEndianness) {
+			T tmp;
+			if (*size >= sizeof(T)) {
+				*size -= sizeof(T);
+				memcpy(&tmp, *buffer, sizeof(T));
+				switch (streamEndianness) {
+				case SerializeIF::Endianness::BIG:
+					*object = EndianConverter::convertBigEndian<T>(tmp);
+					break;
+				case SerializeIF::Endianness::LITTLE:
+					*object = EndianConverter::convertLittleEndian<T>(tmp);
+					break;
+				default:
+				case SerializeIF::Endianness::MACHINE:
+					*object = tmp;
+					break;
+				}
+
+				*buffer += sizeof(T);
+				return HasReturnvaluesIF::RETURN_OK;
+			} else {
+				return SerializeIF::STREAM_TOO_SHORT;
+			}
+		}
+
+		uint32_t getSerializedSize(const T *object) {
+			return sizeof(T);
+		}
+
 	};
 
 	template<typename T>
-class SerializeAdapter {
+	class InternalSerializeAdapter<T, 1> {
 	public:
-	static ReturnValue_t serialize(const T* object, uint8_t** buffer,
+		ReturnValue_t serialize(const T *object, uint8_t **buffer,
-			size_t* size, const size_t max_size, bool bigEndian) {
+				size_t *size, size_t max_size,
-		SerializeAdapter_<T, IsDerivedFrom<T, SerializeIF>::Is> adapter;
+				SerializeIF::Endianness streamEndianness) const {
-		return adapter.serialize(object, buffer, size, max_size, bigEndian);
+			size_t ignoredSize = 0;
+			if (size == NULL) {
+				size = &ignoredSize;
 			}
-	static uint32_t getSerializedSize(const T* object) {
+			return object->serialize(buffer, size, max_size, streamEndianness);
-		SerializeAdapter_<T, IsDerivedFrom<T, SerializeIF>::Is> adapter;
+		}
-		return adapter.getSerializedSize(object);
+		uint32_t getSerializedSize(const T *object) const {
+			return object->getSerializedSize();
 		}
 
-	static ReturnValue_t deSerialize(T* object, const uint8_t** buffer,
+		ReturnValue_t deSerialize(T *object, const uint8_t **buffer,
-			size_t* size, bool bigEndian) {
+				size_t *size, SerializeIF::Endianness streamEndianness) {
-		SerializeAdapter_<T, IsDerivedFrom<T, SerializeIF>::Is> adapter;
+			return object->deSerialize(buffer, size, streamEndianness);
-		return adapter.deSerialize(object, buffer, size, bigEndian);
 		}
 	};
+};
 
 #endif /* SERIALIZEADAPTER_H_ */

serialize/SerializeAdapterInternal.h

@@ -1,118 +0,0 @@
-/**
- * @file 	SerializeAdapterInternal.h
- *
- * @date	13.04.2020
- * @author	R. Mueller
- */
-
-#ifndef FRAMEWORK_SERIALIZE_SERIALIZEADAPTERINTERNAL_H_
-#define FRAMEWORK_SERIALIZE_SERIALIZEADAPTERINTERNAL_H_
-#include <framework/returnvalues/HasReturnvaluesIF.h>
-#include <framework/container/IsDerivedFrom.h>
-#include <framework/serialize/EndianSwapper.h>
-
-/**
- * This template specialization will be chosen for fundamental types or
- * anything else not implementing SerializeIF, based on partial
- * template specialization.
- * @tparam T
- * @tparam
- */
-template<typename T, int>
-class SerializeAdapter_ {
-public:
-	/**
-	 *
-	 * @param object
-	 * @param buffer
-	 * @param size
-	 * @param max_size
-	 * @param bigEndian
-	 * @return
-	 */
-	static ReturnValue_t serialize(const T* object, uint8_t** buffer,
-			size_t* size, const size_t max_size, bool bigEndian) {
-	    // function eventuelly serializes structs here.
-	    // does this work on every architecture?
-	    // static_assert(std::is_fundamental<T>::value);
-		size_t ignoredSize = 0;
-		if (size == nullptr) {
-			size = &ignoredSize;
-		}
-		if (sizeof(T) + *size <= max_size) {
-			T tmp;
-			if (bigEndian) {
-				tmp = EndianSwapper::swap<T>(*object);
-			} else {
-				tmp = *object;
-			}
-			memcpy(*buffer, &tmp, sizeof(T));
-			*size += sizeof(T);
-			(*buffer) += sizeof(T);
-			return HasReturnvaluesIF::RETURN_OK;
-		} else {
-			return SerializeIF::BUFFER_TOO_SHORT;
-		}
-	}
-
-	/**
-	 * Deserialize buffer into object
-	 * @param object [out] Object to be deserialized with buffer data
-	 * @param buffer contains the data. Non-Const pointer to non-const
-	 * 				 pointer to const data.
-	 * @param size Size to deSerialize. wil be decremented by sizeof(T)
-	 * @param bigEndian Specify endianness
-	 * @return
-	 */
-	ReturnValue_t deSerialize(T* object, const uint8_t** buffer, size_t* size,
-			bool bigEndian) {
-		T tmp;
-		if (*size >= sizeof(T)) {
-			*size -= sizeof(T);
-			memcpy(&tmp, *buffer, sizeof(T));
-			if (bigEndian) {
-				*object = EndianSwapper::swap<T>(tmp);
-			} else {
-				*object = tmp;
-			}
-			*buffer += sizeof(T);
-			return HasReturnvaluesIF::RETURN_OK;
-		} else {
-			return SerializeIF::STREAM_TOO_SHORT;
-		}
-	}
-
-	size_t getSerializedSize(const T * object) {
-		return sizeof(T);
-	}
-};
-
-/**
- * This template specialization will be chosen for class derived from
- * SerializeIF, based on partial template specialization.
- * @tparam T
- * @tparam
- */
-template<typename T>
-class SerializeAdapter_<T, true> {
-public:
-	ReturnValue_t serialize(const T* object, uint8_t** buffer, size_t* size,
-			const size_t max_size, bool bigEndian) const {
-		size_t ignoredSize = 0;
-		if (size == NULL) {
-			size = &ignoredSize;
-		}
-		return object->serialize(buffer, size, max_size, bigEndian);
-	}
-
-	size_t getSerializedSize(const T* object) const {
-		return object->getSerializedSize();
-	}
-
-	ReturnValue_t deSerialize(T* object, const uint8_t** buffer, size_t* size,
-			bool bigEndian) {
-		return object->deSerialize(buffer, size, bigEndian);
-	}
-};
-
-#endif /* FRAMEWORK_SERIALIZE_SERIALIZEADAPTERINTERNAL_H_ */

serialize/SerializeElement.h

@@ -19,32 +19,29 @@
 template<typename T>
 class SerializeElement: public SerializeIF, public LinkedElement<SerializeIF> {
 public:
-	/**
-	 * Arguments are forwarded to the element datatype constructor
-	 * @param args
-	 */
 	template<typename ... Args>
 	SerializeElement(Args ... args) :
-			LinkedElement<SerializeIF>(this),
+			LinkedElement<SerializeIF>(this), entry(std::forward<Args>(args)...) {
-			entry(std::forward<Args>(args)...) {}
-
-	SerializeElement() : LinkedElement<SerializeIF>(this) {}
 
+	}
+	SerializeElement() :
+			LinkedElement<SerializeIF>(this) {
+	}
 	T entry;
-
+	ReturnValue_t serialize(uint8_t **buffer, size_t *size, size_t maxSize,
-	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+			Endianness streamEndianness) const override {
-			const size_t max_size, bool bigEndian) const override {
+		return SerializeAdapter::serialize(&entry, buffer, size, maxSize,
-		return SerializeAdapter<T>::serialize(&entry, buffer, size,
+				streamEndianness);
-				max_size, bigEndian);
 	}
 
-	size_t getSerializedSize() const {
+	size_t getSerializedSize() const override {
-		return SerializeAdapter<T>::getSerializedSize(&entry);
+		return SerializeAdapter::getSerializedSize(&entry);
 	}
 
 	virtual ReturnValue_t deSerialize(const uint8_t **buffer, size_t *size,
-			bool bigEndian) override {
+			Endianness streamEndianness) override {
-		return SerializeAdapter<T>::deSerialize(&entry, buffer, size, bigEndian);
+		return SerializeAdapter::deSerialize(&entry, buffer, size,
+				streamEndianness);
 	}
 
 	operator T() {
@@ -60,6 +57,4 @@ public:
 	}
 };
 
-
-
 #endif /* SERIALIZEELEMENT_H_ */

serialize/SerializeIF.h

@@ -33,6 +33,10 @@
  */
 class SerializeIF {
 public:
+	enum class Endianness : uint8_t {
+		BIG, LITTLE, MACHINE
+	};
+
 	static const uint8_t INTERFACE_ID = CLASS_ID::SERIALIZE_IF;
 	static const ReturnValue_t BUFFER_TOO_SHORT = MAKE_RETURN_CODE(1);
 	static const ReturnValue_t STREAM_TOO_SHORT = MAKE_RETURN_CODE(2);
@@ -42,12 +46,12 @@ public:
 	}
 
 	virtual ReturnValue_t serialize(uint8_t **buffer, size_t *size,
-			const size_t max_size, bool bigEndian) const = 0;
+			size_t maxSize, Endianness streamEndianness) const = 0;
 
 	virtual size_t getSerializedSize() const = 0;
 
 	virtual ReturnValue_t deSerialize(const uint8_t **buffer, size_t *size,
-			bool bigEndian) = 0;
+			Endianness streamEndianness) = 0;
 
 };
 

subsystem/Subsystem.cpp

@@ -75,7 +75,8 @@ void Subsystem::performChildOperation() {
 	if (isInTransition) {
 		if (commandsOutstanding <= 0) { //all children of the current table were commanded and replied
 			if (currentSequenceIterator.value == NULL) { //we're through with this sequence
-				if (checkStateAgainstTable(currentTargetTable, targetSubmode) == RETURN_OK) {
+				if (checkStateAgainstTable(currentTargetTable, targetSubmode)
+						== RETURN_OK) {
 					setMode(targetMode, targetSubmode);
 					isInTransition = false;
 					return;
@@ -86,7 +87,8 @@ void Subsystem::performChildOperation() {
 				}
 			}
 			if (currentSequenceIterator->checkSuccess()) {
-				if (checkStateAgainstTable(getCurrentTable(), targetSubmode) != RETURN_OK) {
+				if (checkStateAgainstTable(getCurrentTable(), targetSubmode)
+						!= RETURN_OK) {
 					transitionFailed(TABLE_CHECK_FAILED,
 							currentSequenceIterator->getTableId());
 					return;
@@ -117,7 +119,8 @@ void Subsystem::performChildOperation() {
 			childrenChangedHealth = false;
 			startTransition(mode, submode);
 		} else if (childrenChangedMode) {
-			if (checkStateAgainstTable(currentTargetTable, submode) != RETURN_OK) {
+			if (checkStateAgainstTable(currentTargetTable, submode)
+					!= RETURN_OK) {
 				triggerEvent(CANT_KEEP_MODE, mode, submode);
 				cantKeepMode();
 			}
@@ -169,11 +172,12 @@ ReturnValue_t Subsystem::handleCommandMessage(CommandMessage* message) {
 		if (result == RETURN_OK) {
 			Mode_t fallbackId;
 			size_t size = sizeRead;
-			result = SerializeAdapter<Mode_t>::deSerialize(&fallbackId,
+			result = SerializeAdapter::deSerialize(&fallbackId, &pointer, &size,
-					&pointer, &size, true);
+					SerializeIF::Endianness::BIG);
 			if (result == RETURN_OK) {
 				result = SerialArrayListAdapter<ModeListEntry>::deSerialize(
-						&sequence, &pointer, &size, true);
+						&sequence, &pointer, &size,
+						SerializeIF::Endianness::BIG);
 				if (result == RETURN_OK) {
 					result = addSequence(&sequence,
 							ModeSequenceMessage::getSequenceId(message),
@@ -195,7 +199,7 @@ ReturnValue_t Subsystem::handleCommandMessage(CommandMessage* message) {
 		if (result == RETURN_OK) {
 			size_t size = sizeRead;
 			result = SerialArrayListAdapter<ModeListEntry>::deSerialize(&table,
-					&pointer, &size, true);
+					&pointer, &size, SerializeIF::Endianness::BIG);
 			if (result == RETURN_OK) {
 				result = addTable(&table,
 						ModeSequenceMessage::getSequenceId(message));
@@ -615,7 +619,8 @@ void Subsystem::sendSerializablesAsCommandMessage(Command_t command,
 		return;
 	}
 	for (uint8_t i = 0; i < count; i++) {
-		elements[i]->serialize(&storeBuffer, &size, maxSize, true);
+		elements[i]->serialize(&storeBuffer, &size, maxSize,
+				SerializeIF::Endianness::BIG);
 	}
 	CommandMessage reply;
 	ModeSequenceMessage::setModeSequenceMessage(&reply, command, address);

subsystem/modes/ModeDefinitions.h

@@ -19,31 +19,31 @@ public:
 	uint8_t value4;
 
 	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
-			const size_t max_size, bool bigEndian) const {
+			size_t maxSize, Endianness streamEndianness) const {
 
 		ReturnValue_t result;
 
-		result = SerializeAdapter<uint32_t>::serialize(&value1, buffer, size,
+		result = SerializeAdapter::serialize(&value1, buffer, size,
-				max_size, bigEndian);
+				maxSize, streamEndianness);
 
 		if (result != HasReturnvaluesIF::RETURN_OK) {
 			return result;
 		}
-		result = SerializeAdapter<uint32_t>::serialize(&value2, buffer, size,
+		result = SerializeAdapter::serialize(&value2, buffer, size,
-				max_size, bigEndian);
+				maxSize, streamEndianness);
 
 		if (result != HasReturnvaluesIF::RETURN_OK) {
 			return result;
 		}
-		result = SerializeAdapter<uint8_t>::serialize(&value3, buffer, size,
+		result = SerializeAdapter::serialize(&value3, buffer, size,
-				max_size, bigEndian);
+				maxSize, streamEndianness);
 
 		if (result != HasReturnvaluesIF::RETURN_OK) {
 			return result;
 		}
 
-		result = SerializeAdapter<uint8_t>::serialize(&value4, buffer, size,
+		result = SerializeAdapter::serialize(&value4, buffer, size,
-				max_size, bigEndian);
+				maxSize, streamEndianness);
 
 		return result;
 
@@ -54,29 +54,29 @@ public:
 	}
 
 	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
-	bool bigEndian) {
+	Endianness streamEndianness) {
 		ReturnValue_t result;
 
-		result = SerializeAdapter<uint32_t>::deSerialize(&value1, buffer, size,
+		result = SerializeAdapter::deSerialize(&value1, buffer, size,
-				bigEndian);
+				streamEndianness);
 
 		if (result != HasReturnvaluesIF::RETURN_OK) {
 			return result;
 		}
-		result = SerializeAdapter<uint32_t>::deSerialize(&value2, buffer, size,
+		result = SerializeAdapter::deSerialize(&value2, buffer, size,
-				bigEndian);
+				streamEndianness);
 
 		if (result != HasReturnvaluesIF::RETURN_OK) {
 			return result;
 		}
-		result = SerializeAdapter<uint8_t>::deSerialize(&value3, buffer, size,
+		result = SerializeAdapter::deSerialize(&value3, buffer, size,
-				bigEndian);
+				streamEndianness);
 
 		if (result != HasReturnvaluesIF::RETURN_OK) {
 			return result;
 		}
-		result = SerializeAdapter<uint8_t>::deSerialize(&value4, buffer, size,
+		result = SerializeAdapter::deSerialize(&value4, buffer, size,
-				bigEndian);
+				streamEndianness);
 
 		return result;
 	}

thermal/ThermalComponent.cpp

@@ -45,14 +45,14 @@ ReturnValue_t ThermalComponent::setLimits(const uint8_t* data, size_t size) {
 		return MonitoringIF::INVALID_SIZE;
 	}
 	size_t readSize = size;
-	SerializeAdapter<float>::deSerialize(&nopParameters.lowerNopLimit, &data,
+	SerializeAdapter::deSerialize(&nopParameters.lowerNopLimit, &data,
-			&readSize, true);
+			&readSize, SerializeIF::Endianness::BIG);
-	SerializeAdapter<float>::deSerialize(&parameters.lowerOpLimit, &data,
+	SerializeAdapter::deSerialize(&parameters.lowerOpLimit, &data,
-			&readSize, true);
+			&readSize, SerializeIF::Endianness::BIG);
-	SerializeAdapter<float>::deSerialize(&parameters.upperOpLimit, &data,
+	SerializeAdapter::deSerialize(&parameters.upperOpLimit, &data,
-			&readSize, true);
+			&readSize, SerializeIF::Endianness::BIG);
-	SerializeAdapter<float>::deSerialize(&nopParameters.upperNopLimit, &data,
+	SerializeAdapter::deSerialize(&nopParameters.upperNopLimit, &data,
-			&readSize, true);
+			&readSize, SerializeIF::Endianness::BIG);
 	return HasReturnvaluesIF::RETURN_OK;
 }
 

tmstorage/TmStorePackets.h

@@ -33,14 +33,14 @@ public:
 	uint16_t apid;
 	uint16_t ssc;
 	ReturnValue_t serialize(uint8_t** buffer, size_t* size,
-			const size_t max_size, bool bigEndian) const {
+			size_t maxSize, Endianness streamEndianness) const {
-		ReturnValue_t result = SerializeAdapter<uint16_t>::serialize(&apid,
+		ReturnValue_t result = SerializeAdapter::serialize(&apid,
-				buffer, size, max_size, bigEndian);
+				buffer, size, maxSize, streamEndianness);
 		if (result != HasReturnvaluesIF::RETURN_OK) {
 			return result;
 		}
-		return SerializeAdapter<uint16_t>::serialize(&ssc, buffer, size,
+		return SerializeAdapter::serialize(&ssc, buffer, size,
-				max_size, bigEndian);
+				maxSize, streamEndianness);
 
 	}
 
@@ -49,14 +49,14 @@ public:
 	}
 
 	ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
-	bool bigEndian) {
+	        Endianness streamEndianness) {
-		ReturnValue_t result = SerializeAdapter<uint16_t>::deSerialize(&apid,
+		ReturnValue_t result = SerializeAdapter::deSerialize(&apid,
-				buffer, size, bigEndian);
+				buffer, size, streamEndianness);
 		if (result != HasReturnvaluesIF::RETURN_OK) {
 			return result;
 		}
-		return SerializeAdapter<uint16_t>::deSerialize(&ssc, buffer, size,
+		return SerializeAdapter::deSerialize(&ssc, buffer, size,
-				bigEndian);
+				streamEndianness);
 	}
 };
 
@@ -219,38 +219,38 @@ public:
 
 
 	ReturnValue_t serialize(uint8_t** buffer, size_t* size,
-			const size_t max_size, bool bigEndian) const {
+			size_t maxSize, Endianness streamEndianness) const {
-		ReturnValue_t result = AutoSerializeAdapter::serialize(&apid,buffer,size,max_size,bigEndian);
+		ReturnValue_t result = SerializeAdapter::serialize(&apid,buffer,size,maxSize,streamEndianness);
 		if(result!=HasReturnvaluesIF::RETURN_OK){
 			return result;
 		}
-		result = AutoSerializeAdapter::serialize(&sourceSequenceCount,buffer,size,max_size,bigEndian);
+		result = SerializeAdapter::serialize(&sourceSequenceCount,buffer,size,maxSize,streamEndianness);
 		if(result!=HasReturnvaluesIF::RETURN_OK){
 			return result;
 		}
-		result = AutoSerializeAdapter::serialize(&serviceType,buffer,size,max_size,bigEndian);
+		result = SerializeAdapter::serialize(&serviceType,buffer,size,maxSize,streamEndianness);
 		if(result!=HasReturnvaluesIF::RETURN_OK){
 			return result;
 		}
-		result = AutoSerializeAdapter::serialize(&serviceSubtype,buffer,size,max_size,bigEndian);
+		result = SerializeAdapter::serialize(&serviceSubtype,buffer,size,maxSize,streamEndianness);
 		if(result!=HasReturnvaluesIF::RETURN_OK){
 			return result;
 		}
-		result = AutoSerializeAdapter::serialize(&subCounter,buffer,size,max_size,bigEndian);
+		result = SerializeAdapter::serialize(&subCounter,buffer,size,maxSize,streamEndianness);
 		if(result!=HasReturnvaluesIF::RETURN_OK){
 			return result;
 		}
 		SerialBufferAdapter<uint8_t> adapter(rawTimestamp,sizeof(rawTimestamp));
-		return adapter.serialize(buffer,size,max_size,bigEndian);
+		return adapter.serialize(buffer,size,maxSize,streamEndianness);
 	}
 
 	size_t getSerializedSize() const {
 		uint32_t size = 0;
-		size += AutoSerializeAdapter::getSerializedSize(&apid);
+		size += SerializeAdapter::getSerializedSize(&apid);
-		size += AutoSerializeAdapter::getSerializedSize(&sourceSequenceCount);
+		size += SerializeAdapter::getSerializedSize(&sourceSequenceCount);
-		size += AutoSerializeAdapter::getSerializedSize(&serviceType);
+		size += SerializeAdapter::getSerializedSize(&serviceType);
-		size += AutoSerializeAdapter::getSerializedSize(&serviceSubtype);
+		size += SerializeAdapter::getSerializedSize(&serviceSubtype);
-		size += AutoSerializeAdapter::getSerializedSize(&subCounter);
+		size += SerializeAdapter::getSerializedSize(&subCounter);
 		SerialBufferAdapter<uint8_t> adapter(rawTimestamp,sizeof(rawTimestamp));
 		size += adapter.getSerializedSize();
 		return size;
@@ -258,34 +258,34 @@ public:
 	};
 
 	ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
-	bool bigEndian) {
+	        Endianness streamEndianness) {
-		ReturnValue_t result = AutoSerializeAdapter::deSerialize(&apid, buffer,
+		ReturnValue_t result = SerializeAdapter::deSerialize(&apid, buffer,
-				size, bigEndian);
+				size, streamEndianness);
 		if (result != HasReturnvaluesIF::RETURN_OK) {
 			return result;
 		}
-		result = AutoSerializeAdapter::deSerialize(&sourceSequenceCount, buffer,
+		result = SerializeAdapter::deSerialize(&sourceSequenceCount, buffer,
-				size, bigEndian);
+				size, streamEndianness);
 		if (result != HasReturnvaluesIF::RETURN_OK) {
 			return result;
 		}
-		result = AutoSerializeAdapter::deSerialize(&serviceType, buffer, size,
+		result = SerializeAdapter::deSerialize(&serviceType, buffer, size,
-				bigEndian);
+				streamEndianness);
 		if (result != HasReturnvaluesIF::RETURN_OK) {
 			return result;
 		}
-		result = AutoSerializeAdapter::deSerialize(&serviceSubtype, buffer,
+		result = SerializeAdapter::deSerialize(&serviceSubtype, buffer,
-				size, bigEndian);
+				size, streamEndianness);
 		if (result != HasReturnvaluesIF::RETURN_OK) {
 			return result;
 		}
-		result = AutoSerializeAdapter::deSerialize(&subCounter, buffer, size,
+		result = SerializeAdapter::deSerialize(&subCounter, buffer, size,
-				bigEndian);
+				streamEndianness);
 		if (result != HasReturnvaluesIF::RETURN_OK) {
 			return result;
 		}
 		SerialBufferAdapter<uint8_t> adapter(rawTimestamp,sizeof(rawTimestamp));
-		return adapter.deSerialize(buffer,size,bigEndian);
+		return adapter.deSerialize(buffer,size,streamEndianness);
 	}
 
 private:

tmtcpacket/packetmatcher/ApidMatcher.h

@@ -23,17 +23,15 @@ public:
 		}
 	}
 	ReturnValue_t serialize(uint8_t** buffer, size_t* size,
-			const size_t max_size, bool bigEndian) const {
+			size_t maxSize, Endianness streamEndianness) const {
-		return SerializeAdapter<uint16_t>::serialize(&apid, buffer,
+		return SerializeAdapter::serialize(&apid, buffer, size, maxSize, streamEndianness);
-				size, max_size, bigEndian);
 	}
 	size_t getSerializedSize() const {
-		return SerializeAdapter<uint16_t>::getSerializedSize(&apid);
+		return SerializeAdapter::getSerializedSize(&apid);
 	}
 	ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
-			bool bigEndian) {
+			Endianness streamEndianness) {
-		return SerializeAdapter<uint16_t>::deSerialize(&apid, buffer,
+		return SerializeAdapter::deSerialize(&apid, buffer, size, streamEndianness);
-				size, bigEndian);
 	}
 };
 

tmtcpacket/packetmatcher/ServiceMatcher.h

@@ -23,17 +23,15 @@ public:
 		}
 	}
 	ReturnValue_t serialize(uint8_t** buffer, size_t* size,
-			const size_t max_size, bool bigEndian) const {
+			size_t maxSize, Endianness streamEndianness) const {
-		return SerializeAdapter<uint8_t>::serialize(&service, buffer,
+		return SerializeAdapter::serialize(&service, buffer, size, maxSize, streamEndianness);
-				size, max_size, bigEndian);
 	}
 	size_t getSerializedSize() const {
-		return SerializeAdapter<uint8_t>::getSerializedSize(&service);
+		return SerializeAdapter::getSerializedSize(&service);
 	}
 	ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
-			bool bigEndian) {
+			Endianness streamEndianness) {
-		return SerializeAdapter<uint8_t>::deSerialize(&service, buffer,
+		return SerializeAdapter::deSerialize(&service, buffer, size, streamEndianness);
-				size, bigEndian);
 	}
 };
 

tmtcpacket/packetmatcher/SubserviceMatcher.h

@@ -21,17 +21,15 @@ public:
 		}
 	}
 	ReturnValue_t serialize(uint8_t** buffer, size_t* size,
-			const size_t max_size, bool bigEndian) const {
+			size_t maxSize, Endianness streamEndianness) const {
-		return SerializeAdapter<uint8_t>::serialize(&subService, buffer, size,
+		return SerializeAdapter::serialize(&subService, buffer, size, maxSize, streamEndianness);
-				max_size, bigEndian);
 	}
 	size_t getSerializedSize() const {
-		return SerializeAdapter<uint8_t>::getSerializedSize(&subService);
+		return SerializeAdapter::getSerializedSize(&subService);
 	}
 	ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
-			bool bigEndian) {
+			Endianness streamEndianness) {
-		return SerializeAdapter<uint8_t>::deSerialize(&subService, buffer,
+		return SerializeAdapter::deSerialize(&subService, buffer, size, streamEndianness);
-				size, bigEndian);
 	}
 private:
 	uint8_t subService;

tmtcpacket/pus/TmPacketStored.cpp

@@ -60,10 +60,12 @@ TmPacketStored::TmPacketStored(uint16_t apid, uint8_t service,
 	uint8_t *putDataHere = getSourceData();
 	size_t size = 0;
 	if (header != NULL) {
-		header->serialize(&putDataHere, &size, sourceDataSize, true);
+		header->serialize(&putDataHere, &size, sourceDataSize,
+				SerializeIF::Endianness::BIG);
 	}
 	if (content != NULL) {
-		content->serialize(&putDataHere, &size, sourceDataSize, true);
+		content->serialize(&putDataHere, &size, sourceDataSize,
+				SerializeIF::Endianness::BIG);
 	}
 	setPacketDataLength(
 			sourceDataSize + sizeof(PUSTmDataFieldHeader) + CRC_SIZE - 1);

tmtcservices/CommandingServiceBase.cpp

@@ -268,8 +268,8 @@ ReturnValue_t CommandingServiceBase::sendTmPacket(uint8_t subservice,
     uint8_t buffer[sizeof(object_id_t)];
     uint8_t* pBuffer = buffer;
     size_t size = 0;
-    SerializeAdapter<object_id_t>::serialize(&objectId, &pBuffer, &size,
+    SerializeAdapter::serialize(&objectId, &pBuffer, &size,
-            sizeof(object_id_t), true);
+                sizeof(object_id_t), SerializeIF::Endianness::BIG);
     TmPacketStored tmPacketStored(this->apid, this->service, subservice,
             this->tmPacketCounter, data, dataLen, buffer, size);
     ReturnValue_t result = tmPacketStored.sendPacket(

tmtcservices/CommandingServiceBase.h

@@ -10,7 +10,7 @@
 #include <framework/tmtcservices/VerificationReporter.h>
 #include <framework/ipc/CommandMessage.h>
 #include <framework/container/FixedMap.h>
-#include <framework/container/FIFO.h>
+#include <framework/container/StaticFIFO.h>
 #include <framework/serialize/SerializeIF.h>
 
 class TcPacketStored;
@@ -89,7 +89,7 @@ public:
 	 */
 	virtual MessageQueueId_t getCommandQueue();
 
-	virtual ReturnValue_t initialize();
+	virtual ReturnValue_t initialize() override;
 
 	/**
 	 * Implementation of ExecutableObjectIF function
@@ -199,7 +199,7 @@ protected:
 		uint32_t state;
 		Command_t command;
 		object_id_t objectId;
-		FIFO<store_address_t, 3> fifo;
+		fsfw::StaticFIFO<store_address_t, 3> fifo;
 	};
 
 	using CommandMapIter = FixedMap<MessageQueueId_t,

tmtcservices/PusParser.cpp

@@ -0,0 +1,115 @@
+#include <framework/tmtcservices/PusParser.h>
+#include <framework/serviceinterface/ServiceInterfaceStream.h>
+
+PusParser::PusParser(uint16_t maxExpectedPusPackets,
+		bool storeSplitPackets): indexSizePairFIFO(maxExpectedPusPackets) {
+}
+
+ReturnValue_t PusParser::parsePusPackets(const uint8_t *frame,
+		size_t frameSize) {
+	if(frame == nullptr) {
+		sif::error << "PusParser::parsePusPackets: Frame pointers in invalid!"
+				<< std::endl;
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+
+	if(indexSizePairFIFO.full()) {
+		sif::error << "PusParser::parsePusPackets: FIFO is full!" << std::endl;
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+
+	size_t lengthField = frame[4] << 8 | frame[5];
+
+	if(lengthField == 0) {
+		return NO_PACKET_FOUND;
+	}
+
+	size_t packetSize = lengthField + 7;
+	// Size of a pus packet is the value in the packet length field plus 7.
+	if(packetSize > frameSize)
+	{
+		if(storeSplitPackets)
+		{
+			indexSizePairFIFO.insert(indexSizePair(0, frameSize));
+		}
+		else
+		{
+			sif::debug << "TcSerialPollingTask::readNextPacket: Next packet "
+					"larger than remaining frame," << std::endl;
+			sif::debug << "Throwing away packet. Detected packet size: "
+					<< packetSize << std::endl;
+		}
+		return SPLIT_PACKET;
+	}
+	else
+	{
+		indexSizePairFIFO.insert(indexSizePair(0, packetSize));
+		if(packetSize == frameSize) {
+			return HasReturnvaluesIF::RETURN_OK;
+		}
+	}
+
+	// packet size is smaller than frame size, parse for more packets.
+	return readMultiplePackets(frame, frameSize, packetSize);
+}
+
+ReturnValue_t PusParser::readMultiplePackets(const uint8_t *frame,
+		size_t frameSize, size_t startIndex) {
+	while (startIndex < frameSize) {
+		ReturnValue_t result = readNextPacket(frame, frameSize, startIndex);
+		if(result != HasReturnvaluesIF::RETURN_OK) {
+			return result;
+		}
+	}
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+fsfw::FIFO<PusParser::indexSizePair>* PusParser::fifo(){
+	return &indexSizePairFIFO;
+}
+
+PusParser::indexSizePair PusParser::getNextFifoPair() {
+	indexSizePair nextIndexSizePair;
+	indexSizePairFIFO.retrieve(&nextIndexSizePair);
+	return nextIndexSizePair;
+}
+
+ReturnValue_t PusParser::readNextPacket(const uint8_t *frame,
+		size_t frameSize, size_t& currentIndex) {
+	// sif::debug << startIndex << std::endl;
+	uint16_t lengthField = frame[currentIndex + 4] << 8 |
+			frame[currentIndex + 5];
+	if(lengthField == 0) {
+		// It is assumed that no packet follows.
+		currentIndex = frameSize;
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+	size_t nextPacketSize = lengthField + 7;
+	size_t remainingSize = frameSize - currentIndex;
+	if(nextPacketSize > remainingSize)
+	{
+		if(storeSplitPackets)
+		{
+			indexSizePairFIFO.insert(indexSizePair(currentIndex, remainingSize));
+		}
+		else
+		{
+			sif::debug << "TcSerialPollingTask::readNextPacket: Next packet "
+					"larger than remaining frame," << std::endl;
+			sif::debug << "Throwing away packet. Detected packet size: "
+					<< nextPacketSize << std::endl;
+		}
+		return SPLIT_PACKET;
+	}
+
+	ReturnValue_t result = indexSizePairFIFO.insert(indexSizePair(currentIndex,
+			nextPacketSize));
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		// FIFO full.
+		sif::debug << "PusParser: Issue inserting into start index size "
+		        "FIFO, it is full!" << std::endl;
+	}
+	currentIndex += nextPacketSize;
+
+	return result;
+}

tmtcservices/PusParser.h

@@ -0,0 +1,82 @@
+#ifndef FRAMEWORK_TMTCSERVICES_PUSPARSER_H_
+#define FRAMEWORK_TMTCSERVICES_PUSPARSER_H_
+
+#include <framework/container/FIFO.h>
+
+#include <utility>
+#include <cstdint>
+
+/**
+ * @brief	This small helper class scans a given buffer for PUS packets.
+ * 			Can be used if PUS packets are serialized in a tightly packed frame.
+ * @details
+ * The parser uses the payload length field of PUS packets to find
+ * the respective PUS packet sizes.
+ *
+ * The parser parses a buffer by taking a pointer and the maximum size to scan.
+ * If PUS packets are found, they are stored in a FIFO which stores pairs
+ * consisting of the index in the buffer and the respective packet sizes.
+ *
+ * If the parser detects split packets (which means that the size of the
+ * next packet is larger than the remaining size to scan), it can either
+ * store that split packet or throw away the packet.
+ */
+class PusParser {
+public:
+	//! The first entry is the index inside the buffer while the second index
+	//! is the size of the PUS packet starting at that index.
+	using indexSizePair = std::pair<size_t, size_t>;
+
+	static constexpr uint8_t INTERFACE_ID = CLASS_ID::PUS_PARSER;
+	static constexpr ReturnValue_t NO_PACKET_FOUND = MAKE_RETURN_CODE(0x00);
+	static constexpr ReturnValue_t SPLIT_PACKET = MAKE_RETURN_CODE(0x01);
+	/**
+	 * Parser constructor.
+	 * @param maxExpectedPusPackets
+	 * Maximum expected number of PUS packets. A good estimate is to divide
+	 * the frame size by the minimum size of a PUS packet (12 bytes)
+	 * @param storeSplitPackets
+	 * Specifies whether split packets are also stored inside the FIFO,
+	 * with the size being the remaining frame size.
+	 */
+	PusParser(uint16_t maxExpectedPusPackets, bool storeSplitPackets);
+
+	/**
+	 * Parse a given frame for PUS packets
+	 * @param frame
+	 * @param frameSize
+	 * @return -@c NO_PACKET_FOUND if no packet was found.
+	 */
+	ReturnValue_t parsePusPackets(const uint8_t* frame, size_t frameSize);
+
+	/**
+	 * Accessor function to get a reference to the internal FIFO which
+	 * stores pairs of indexi and packet sizes. This FIFO is filled
+	 * by the parsePusPackets() function.
+	 * @return
+	 */
+	fsfw::FIFO<indexSizePair>* fifo();
+
+	/**
+	 * Retrieve the next index and packet size pair from the FIFO.
+	 * This also removed it from the FIFO. Please note that if the FIFO
+	 * is empty, an empty pair will be returned.
+	 * @return
+	 */
+	indexSizePair getNextFifoPair();
+private:
+
+	//! A FIFO is used to store information about multiple PUS packets
+	//! inside the receive buffer. The maximum number of entries is defined
+	//! by the first constructor argument.
+	fsfw::FIFO<indexSizePair> indexSizePairFIFO;
+
+	bool storeSplitPackets = false;
+
+	ReturnValue_t readMultiplePackets(const uint8_t *frame, size_t frameSize,
+			size_t startIndex);
+	ReturnValue_t readNextPacket(const uint8_t *frame,
+			size_t frameSize, size_t& startIndex);
+};
+
+#endif /* FRAMEWORK_TMTCSERVICES_PUSPARSER_H_ */

tmtcservices/PusVerificationReport.cpp

@@ -108,13 +108,13 @@ PusSuccessReport::PusSuccessReport(uint16_t setPacketId,
 		uint16_t setSequenceControl, uint8_t setStep) :
 		reportSize(0), pBuffer(reportBuffer) {
 	//Serialization won't fail, because we know the necessary max-size of the buffer.
-	SerializeAdapter<uint16_t>::serialize(&setPacketId, &pBuffer, &reportSize,
+	SerializeAdapter::serialize(&setPacketId, &pBuffer, &reportSize,
-			sizeof(reportBuffer), true);
+			sizeof(reportBuffer), SerializeIF::Endianness::BIG);
-	SerializeAdapter<uint16_t>::serialize(&setSequenceControl, &pBuffer,
+	SerializeAdapter::serialize(&setSequenceControl, &pBuffer, &reportSize,
-			&reportSize, sizeof(reportBuffer), true);
+			sizeof(reportBuffer), SerializeIF::Endianness::BIG);
 	if (setStep != 0) {
-		SerializeAdapter<uint8_t>::serialize(&setStep, &pBuffer, &reportSize,
+		SerializeAdapter::serialize(&setStep, &pBuffer, &reportSize,
-				sizeof(reportBuffer), true);
+				sizeof(reportBuffer), SerializeIF::Endianness::BIG);
 	}
 }
 
@@ -135,26 +135,26 @@ PusFailureReport::PusFailureReport(uint16_t setPacketId,
 		uint8_t setStep, uint32_t parameter1, uint32_t parameter2) :
 		reportSize(0), pBuffer(reportBuffer) {
 	//Serialization won't fail, because we know the necessary max-size of the buffer.
-	SerializeAdapter<uint16_t>::serialize(&setPacketId, &pBuffer, &reportSize,
+	SerializeAdapter::serialize(&setPacketId, &pBuffer, &reportSize,
-			sizeof(reportBuffer), true);
+			sizeof(reportBuffer), SerializeIF::Endianness::BIG);
-	SerializeAdapter<uint16_t>::serialize(&setSequenceControl, &pBuffer,
+	SerializeAdapter::serialize(&setSequenceControl, &pBuffer, &reportSize,
-			&reportSize, sizeof(reportBuffer), true);
+			sizeof(reportBuffer), SerializeIF::Endianness::BIG);
 	if (setStep != 0) {
-		SerializeAdapter<uint8_t>::serialize(&setStep, &pBuffer, &reportSize,
+		SerializeAdapter::serialize(&setStep, &pBuffer, &reportSize,
-				sizeof(reportBuffer), true);
+				sizeof(reportBuffer), SerializeIF::Endianness::BIG);
 	}
-	SerializeAdapter<ReturnValue_t>::serialize(&setErrorCode, &pBuffer,
+	SerializeAdapter::serialize(&setErrorCode, &pBuffer, &reportSize,
-			&reportSize, sizeof(reportBuffer), true);
+			sizeof(reportBuffer), SerializeIF::Endianness::BIG);
-	SerializeAdapter<uint32_t>::serialize(&parameter1, &pBuffer, &reportSize,
+	SerializeAdapter::serialize(&parameter1, &pBuffer, &reportSize,
-			sizeof(reportBuffer), true);
+			sizeof(reportBuffer), SerializeIF::Endianness::BIG);
-	SerializeAdapter<uint32_t>::serialize(&parameter2, &pBuffer, &reportSize,
+	SerializeAdapter::serialize(&parameter2, &pBuffer, &reportSize,
-			sizeof(reportBuffer), true);
+			sizeof(reportBuffer), SerializeIF::Endianness::BIG);
 }
 
 PusFailureReport::~PusFailureReport() {
 }
 
-uint32_t PusFailureReport::getSize() {
+size_t PusFailureReport::getSize() {
 	return reportSize;
 }