Today's the day. Renamed platform to framework.

parameters/HasParametersIF.h

@@ -0,0 +1,59 @@
+/*
+ * HasParametersIF.h
+ *
+ *  Created on: 26.11.2015
+ *      Author: mohr
+ */
+
+#ifndef HASPARAMETERSIF_H_
+#define HASPARAMETERSIF_H_
+
+#include <framework/parameters/ParameterWrapper.h>
+#include <framework/returnvalues/HasReturnvaluesIF.h>
+#include <stdint.h>
+
+typedef uint32_t ParameterId_t;
+
+class HasParametersIF {
+public:
+	static const uint8_t INTERFACE_ID = HAS_PARAMETERS_IF;
+	static const ReturnValue_t INVALID_MATRIX_ID = MAKE_RETURN_CODE(0x01);
+	static const ReturnValue_t INVALID_DOMAIN_ID = MAKE_RETURN_CODE(0x02);
+	static const ReturnValue_t INVALID_VALUE = MAKE_RETURN_CODE(0x03);
+
+
+
+
+	static uint8_t getDomain(ParameterId_t id){
+		return id >> 24;
+	}
+
+	static uint16_t getMatrixId(ParameterId_t id){
+		return id >> 8;
+	}
+
+	static uint8_t getIndex(ParameterId_t id){
+		return id;
+	}
+
+
+	virtual ~HasParametersIF() {
+	}
+
+	/**
+	 * Always set parameter before checking newValues!
+	 *
+	 *
+	 * @param domainId
+	 * @param parameterId
+	 * @param parameterWrapper
+	 * @param newValues
+	 * @param startAtIndex
+	 * @return
+	 */
+	virtual ReturnValue_t getParameter(uint8_t domainId, uint16_t parameterId,
+			ParameterWrapper *parameterWrapper,
+			const ParameterWrapper *newValues, uint16_t startAtIndex) = 0;
+};
+
+#endif /* HASPARAMETERSIF_H_ */

parameters/ParameterHelper.cpp

@@ -0,0 +1,138 @@
+/*
+ * ParameterHelper.cpp
+ *
+ *  Created on: 28.11.2015
+ *      Author: mohr
+ */
+
+#include <framework/objectmanager/ObjectManagerIF.h>
+#include <framework/parameters/ParameterHelper.h>
+#include <framework/parameters/ParameterMessage.h>
+
+ParameterHelper::ParameterHelper(ReceivesParameterMessagesIF* owner) :
+		owner(owner), storage(NULL) {
+	ownerQueueId = owner->getCommandQueue();
+}
+
+ParameterHelper::~ParameterHelper() {
+}
+
+ReturnValue_t ParameterHelper::handleParameterMessage(CommandMessage *message) {
+	ReturnValue_t result = HasReturnvaluesIF::RETURN_FAILED;
+	switch (message->getCommand()) {
+	case ParameterMessage::CMD_PARAMETER_DUMP: {
+		ParameterWrapper description;
+		uint8_t domain = HasParametersIF::getDomain(
+				ParameterMessage::getParameterId(message));
+		uint16_t parameterId = HasParametersIF::getMatrixId(
+				ParameterMessage::getParameterId(message));
+		ReturnValue_t result = owner->getParameter(domain, parameterId,
+				&description, &description, 0);
+		if (result == HasReturnvaluesIF::RETURN_OK) {
+			result = sendParameter(message->getSender(),
+					ParameterMessage::getParameterId(message), &description);
+		}
+	}
+		break;
+	case ParameterMessage::CMD_PARAMETER_LOAD: {
+
+		uint8_t domain = HasParametersIF::getDomain(
+				ParameterMessage::getParameterId(message));
+		uint16_t parameterId = HasParametersIF::getMatrixId(
+				ParameterMessage::getParameterId(message));
+		uint8_t index = HasParametersIF::getIndex(
+				ParameterMessage::getParameterId(message));
+
+		const uint8_t *storedStream;
+		uint32_t storedStreamSize;
+		ReturnValue_t result = storage->getData(
+				ParameterMessage::getStoreId(message), &storedStream,
+				&storedStreamSize);
+		if (result != HasReturnvaluesIF::RETURN_OK) {
+			break;
+		}
+
+		ParameterWrapper streamWrapper;
+		result = streamWrapper.set(storedStream, storedStreamSize);
+		if (result != HasReturnvaluesIF::RETURN_OK) {
+			storage->deleteData(ParameterMessage::getStoreId(message));
+			break;
+		}
+
+		ParameterWrapper ownerWrapper;
+		result = owner->getParameter(domain, parameterId, &ownerWrapper,
+				&streamWrapper, index);
+		if (result != HasReturnvaluesIF::RETURN_OK) {
+			storage->deleteData(ParameterMessage::getStoreId(message));
+			break;
+		}
+
+		result = ownerWrapper.copyFrom(&streamWrapper, index);
+
+		storage->deleteData(ParameterMessage::getStoreId(message));
+
+		if (result == HasReturnvaluesIF::RETURN_OK) {
+			result = sendParameter(message->getSender(),
+					ParameterMessage::getParameterId(message), &ownerWrapper);
+		}
+	}
+		break;
+	default:
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		rejectCommand(message->getSender(), result, message->getCommand());
+	}
+
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t ParameterHelper::sendParameter(MessageQueueId_t to, uint32_t id,
+		const ParameterWrapper* description) {
+	uint32_t serializedSize = description->getSerializedSize();
+
+	uint8_t *storeElement;
+	store_address_t address;
+
+	ReturnValue_t result = storage->getFreeElement(&address, serializedSize,
+			&storeElement);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+
+	uint32_t storeElementSize = 0;
+
+	result = description->serialize(&storeElement, &storeElementSize,
+			serializedSize, true);
+
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		storage->deleteData(address);
+		return result;
+	}
+
+	CommandMessage reply;
+
+	ParameterMessage::setParameterDumpReply(&reply, id, address);
+
+	MessageQueueSender sender;
+	sender.sendMessage(to, &reply, ownerQueueId);
+
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t ParameterHelper::initialize() {
+	storage = objectManager->get<StorageManagerIF>(objects::IPC_STORE);
+	if (storage == NULL) {
+		return HasReturnvaluesIF::RETURN_FAILED;
+	} else {
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+}
+
+void ParameterHelper::rejectCommand(MessageQueueId_t to, ReturnValue_t reason, Command_t initialCommand) {
+	CommandMessage reply;
+	reply.setReplyRejected(reason, initialCommand);
+	MessageQueueSender sender;
+	sender.sendMessage(to, &reply, ownerQueueId);
+}

parameters/ParameterHelper.h

@@ -0,0 +1,34 @@
+/*
+ * ParameterHelper.h
+ *
+ *  Created on: 28.11.2015
+ *      Author: mohr
+ */
+
+#ifndef PARAMETERHELPER_H_
+#define PARAMETERHELPER_H_
+
+#include <framework/parameters/ParameterMessage.h>
+#include <framework/parameters/ReceivesParameterMessagesIF.h>
+
+class ParameterHelper {
+public:
+	ParameterHelper(ReceivesParameterMessagesIF *owner);
+	virtual ~ParameterHelper();
+
+	ReturnValue_t handleParameterMessage(CommandMessage *message);
+
+	ReturnValue_t initialize();
+private:
+	ReceivesParameterMessagesIF *owner;
+
+	MessageQueueId_t ownerQueueId;
+
+	StorageManagerIF *storage;
+
+	ReturnValue_t sendParameter(MessageQueueId_t to, uint32_t id, const ParameterWrapper *description);
+
+	void rejectCommand(MessageQueueId_t to, ReturnValue_t reason, Command_t initialCommand);
+};
+
+#endif /* PARAMETERHELPER_H_ */

parameters/ParameterMessage.cpp

@@ -0,0 +1,38 @@
+/*
+ * ParameterMessage.cpp
+ *
+ *  Created on: 28.11.2015
+ *      Author: mohr
+ */
+
+#include <framework/parameters/ParameterMessage.h>
+
+ParameterId_t ParameterMessage::getParameterId(const CommandMessage* message) {
+	return message->getParameter();
+}
+
+store_address_t ParameterMessage::getStoreId(const CommandMessage* message) {
+	store_address_t address;
+	address.raw = message->getParameter2();
+	return address;
+}
+
+void ParameterMessage::setParameterDumpCommand(CommandMessage* message,
+		ParameterId_t id) {
+	message->setCommand(CMD_PARAMETER_DUMP);
+	message->setParameter(id);
+}
+
+void ParameterMessage::setParameterDumpReply(CommandMessage* message,
+		ParameterId_t id, store_address_t storageID) {
+	message->setCommand(REPLY_PARAMETER_DUMP);
+	message->setParameter(id);
+	message->setParameter2(storageID.raw);
+}
+
+void ParameterMessage::setParameterLoadCommand(CommandMessage* message,
+		ParameterId_t id, store_address_t storageID) {
+	message->setCommand(CMD_PARAMETER_LOAD);
+	message->setParameter(id);
+	message->setParameter2(storageID.raw);
+}

parameters/ParameterMessage.h

@@ -0,0 +1,35 @@
+/*
+ * ParameterMessage.h
+ *
+ *  Created on: 28.11.2015
+ *      Author: mohr
+ */
+
+#ifndef PARAMETERMESSAGE_H_
+#define PARAMETERMESSAGE_H_
+
+#include <framework/ipc/CommandMessage.h>
+#include <framework/parameters/HasParametersIF.h>
+#include <framework/storagemanager/StorageManagerIF.h>
+
+class ParameterMessage {
+private:
+	ParameterMessage();
+public:
+	static const uint8_t MESSAGE_ID = PARAMETER_MESSAGE_ID;
+	static const Command_t CMD_PARAMETER_LOAD = MAKE_COMMAND_ID( 0x01 );
+	static const Command_t CMD_PARAMETER_DUMP = MAKE_COMMAND_ID( 0x02 );
+	static const Command_t REPLY_PARAMETER_DUMP = MAKE_COMMAND_ID( 0x03 );
+
+	static ParameterId_t getParameterId(const CommandMessage* message);
+	static store_address_t getStoreId(const CommandMessage* message);
+	static void setParameterDumpCommand(CommandMessage* message,
+			ParameterId_t id);
+	static void setParameterDumpReply(CommandMessage* message,
+			ParameterId_t id,  store_address_t storageID);
+	static void setParameterLoadCommand(CommandMessage* message,
+			ParameterId_t id, store_address_t storageID);
+
+};
+
+#endif /* PARAMETERMESSAGE_H_ */

parameters/ParameterWrapper.cpp

@@ -0,0 +1,275 @@
+#include <framework/parameters/ParameterWrapper.h>
+
+ParameterWrapper::ParameterWrapper() :
+		pointsToStream(false), type(Type::UNKNOWN_TYPE), rows(0), columns(0), data(
+				NULL), readonlyData(NULL) {
+}
+
+ParameterWrapper::ParameterWrapper(Type type, uint8_t rows, uint8_t columns,
+		void* data) :
+		pointsToStream(false), type(type), rows(rows), columns(columns), data(
+				data), readonlyData(data) {
+}
+
+ParameterWrapper::ParameterWrapper(Type type, uint8_t rows, uint8_t columns,
+		const void* data) :
+		pointsToStream(false), type(type), rows(rows), columns(columns), data(
+				NULL), readonlyData(data) {
+}
+
+ParameterWrapper::~ParameterWrapper() {
+}
+
+ReturnValue_t ParameterWrapper::serialize(uint8_t** buffer, uint32_t* size,
+		const uint32_t max_size, bool bigEndian) const {
+	ReturnValue_t result;
+
+	result = SerializeAdapter<Type>::serialize(&type, buffer, size, max_size,
+			bigEndian);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+
+	result = SerializeAdapter<uint8_t>::serialize(&columns, buffer, size,
+			max_size, bigEndian);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+	result = SerializeAdapter<uint8_t>::serialize(&rows, buffer, size, max_size,
+			bigEndian);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+
+	//serialize uses readonlyData, as it is always valid
+	if (readonlyData == NULL) {
+		return NOT_SET;
+	}
+	switch (type) {
+	case Type::UINT8_T:
+		result = serializeData<uint8_t>(buffer, size, max_size, bigEndian);
+		break;
+	case Type::INT8_T:
+		result = serializeData<int8_t>(buffer, size, max_size, bigEndian);
+		break;
+	case Type::UINT16_T:
+		result = serializeData<uint16_t>(buffer, size, max_size, bigEndian);
+		break;
+	case Type::INT16_T:
+		result = serializeData<int16_t>(buffer, size, max_size, bigEndian);
+		break;
+	case Type::UINT32_T:
+		result = serializeData<uint32_t>(buffer, size, max_size, bigEndian);
+		break;
+	case Type::INT32_T:
+		result = serializeData<int32_t>(buffer, size, max_size, bigEndian);
+		break;
+	case Type::FLOAT:
+		result = serializeData<float>(buffer, size, max_size, bigEndian);
+		break;
+	case Type::DOUBLE:
+		result = serializeData<double>(buffer, size, max_size, bigEndian);
+		break;
+	default:
+		result = UNKNOW_DATATYPE;
+		break;
+	}
+	return result;
+}
+
+uint32_t ParameterWrapper::getSerializedSize() const {
+	uint32_t serializedSize = 0;
+	serializedSize += type.getSerializedSize();
+	serializedSize += sizeof(rows);
+	serializedSize += sizeof(columns);
+	serializedSize += rows * columns * type.getSize();
+
+	return serializedSize;
+}
+
+template<typename T>
+ReturnValue_t ParameterWrapper::serializeData(uint8_t** buffer, uint32_t* size,
+		const uint32_t max_size, bool bigEndian) const {
+	const T *element = (const T*) readonlyData;
+	ReturnValue_t result;
+	uint16_t dataSize = columns * rows;
+	while (dataSize != 0) {
+		result = SerializeAdapter<T>::serialize(element, buffer, size, max_size,
+				bigEndian);
+		if (result != HasReturnvaluesIF::RETURN_OK) {
+			return result;
+		}
+		element++;
+		dataSize--;
+	}
+	return result;
+}
+
+template<typename T>
+ReturnValue_t ParameterWrapper::deSerializeData(uint8_t startingRow,
+		uint8_t startingColumn, const void *from, uint8_t fromRows,
+		uint8_t fromColumns) {
+
+	//treat from as a continuous Stream as we copy all of it
+	const uint8_t *fromAsStream = (const uint8_t *) from;
+	int32_t streamSize = fromRows * fromColumns * sizeof(T);
+
+	ReturnValue_t result;
+
+	for (uint8_t fromRow = 0; fromRow < fromRows; fromRow++) {
+
+		//get the start element of this row in data
+		T *dataWithDataType = ((T *) data)
+				+ (((startingRow + fromRow) * columns) + startingColumn);
+
+		for (uint8_t fromColumn = 0; fromColumn < fromColumns; fromColumn++) {
+			result = SerializeAdapter<T>::deSerialize(
+					dataWithDataType + fromColumn, &fromAsStream, &streamSize,
+					true);
+			if (result != HasReturnvaluesIF::RETURN_OK) {
+				return result;
+			}
+		}
+	}
+
+	return result;
+
+}
+
+ReturnValue_t ParameterWrapper::deSerialize(const uint8_t** buffer,
+		int32_t* size, bool bigEndian) {
+	return deSerialize(buffer, size, bigEndian, 0);
+}
+
+ReturnValue_t ParameterWrapper::deSerialize(const uint8_t** buffer,
+		int32_t* size, bool bigEndian, uint16_t startWritingAtIndex) {
+	ParameterWrapper streamDescription;
+
+	ReturnValue_t result = streamDescription.set(*buffer, *size, buffer, size);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+
+	return copyFrom(&streamDescription, startWritingAtIndex);
+}
+
+ReturnValue_t ParameterWrapper::set(const uint8_t* stream, int32_t streamSize,
+		const uint8_t **remainingStream, int32_t *remainingSize) {
+	ReturnValue_t result = SerializeAdapter<Type>::deSerialize(&type, &stream,
+			&streamSize, true);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+
+	result = SerializeAdapter<uint8_t>::deSerialize(&columns, &stream,
+			&streamSize, true);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+	result = SerializeAdapter<uint8_t>::deSerialize(&rows, &stream, &streamSize,
+			true);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+
+	int32_t dataSize = type.getSize() * rows * columns;
+
+	if (streamSize < dataSize) {
+		return SerializeIF::STREAM_TOO_SHORT;
+	}
+
+	data = NULL;
+	readonlyData = stream;
+	pointsToStream = true;
+
+	stream += dataSize;
+	if (remainingStream != NULL) {
+		*remainingStream = stream;
+	}
+	streamSize -= dataSize;
+	if (remainingSize != NULL) {
+		*remainingSize = streamSize;
+	}
+
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t ParameterWrapper::copyFrom(const ParameterWrapper* from,
+		uint16_t startWritingAtIndex) {
+	if (data == NULL) {
+		return READONLY;
+	}
+
+	if (from->readonlyData == NULL) {
+		return SOURCE_NOT_SET;
+	}
+
+	if (type != from->type) {
+		return DATATYPE_MISSMATCH;
+	}
+
+	//check if from fits into this
+	uint8_t startingRow = startWritingAtIndex / columns;
+	uint8_t startingColumn = startWritingAtIndex % columns;
+
+	if ((from->rows > (rows - startingRow))
+			|| (from->columns > (columns - startingColumn))) {
+		return TOO_BIG;
+	}
+
+	uint8_t typeSize = type.getSize();
+
+	ReturnValue_t result;
+	//copy data
+	if (from->pointsToStream) {
+		switch (type) {
+		case Type::UINT8_T:
+			result = deSerializeData<uint8_t>(startingRow, startingColumn,
+					from->readonlyData, from->rows, from->columns);
+			break;
+		case Type::INT8_T:
+			result = deSerializeData<int8_t>(startingRow, startingColumn,
+					from->readonlyData, from->rows, from->columns);
+			break;
+		case Type::UINT16_T:
+			result = deSerializeData<uint16_t>(startingRow, startingColumn,
+					from->readonlyData, from->rows, from->columns);
+			break;
+		case Type::INT16_T:
+			result = deSerializeData<int16_t>(startingRow, startingColumn,
+					from->readonlyData, from->rows, from->columns);
+			break;
+		case Type::UINT32_T:
+			result = deSerializeData<uint32_t>(startingRow, startingColumn,
+					from->readonlyData, from->rows, from->columns);
+			break;
+		case Type::INT32_T:
+			result = deSerializeData<int32_t>(startingRow, startingColumn,
+					from->readonlyData, from->rows, from->columns);
+			break;
+		case Type::FLOAT:
+			result = deSerializeData<float>(startingRow, startingColumn,
+					from->readonlyData, from->rows, from->columns);
+			break;
+		case Type::DOUBLE:
+			result = deSerializeData<double>(startingRow, startingColumn,
+					from->readonlyData, from->rows, from->columns);
+			break;
+		default:
+			result = UNKNOW_DATATYPE;
+			break;
+		}
+	} else {
+		//need a type to do arithmetic
+		uint8_t *toDataWithType = (uint8_t *) data;
+		for (uint8_t fromRow = 0; fromRow < from->rows; fromRow++) {
+			memcpy(
+					toDataWithType
+							+ (((startingRow + fromRow) * columns)
+									+ startingColumn) * typeSize,
+					from->readonlyData, typeSize * from->columns);
+		}
+	}
+
+	return HasReturnvaluesIF::RETURN_OK;
+}

parameters/ParameterWrapper.h

@@ -0,0 +1,139 @@
+#ifndef PARAMETERWRAPPER_H_
+#define PARAMETERWRAPPER_H_
+
+#include <framework/globalfunctions/Type.h>
+#include <framework/returnvalues/HasReturnvaluesIF.h>
+#include <framework/serialize/SerializeAdapter.h>
+#include <framework/serialize/SerializeIF.h>
+#include <stddef.h>
+#include <framework/globalfunctions/Type.h>
+
+class ParameterWrapper: public SerializeIF {
+public:
+	static const uint8_t INTERFACE_ID = PARAMETER_WRAPPER;
+	static const ReturnValue_t UNKNOW_DATATYPE = MAKE_RETURN_CODE(0x01);
+	static const ReturnValue_t DATATYPE_MISSMATCH = MAKE_RETURN_CODE(0x02);
+	static const ReturnValue_t READONLY = MAKE_RETURN_CODE(0x03);
+	static const ReturnValue_t TOO_BIG = MAKE_RETURN_CODE(0x04);
+	static const ReturnValue_t SOURCE_NOT_SET = MAKE_RETURN_CODE(0x05);
+	static const ReturnValue_t OUT_OF_BOUNDS = MAKE_RETURN_CODE(0x06);
+	static const ReturnValue_t NOT_SET = MAKE_RETURN_CODE(0x07);
+
+	ParameterWrapper();
+	ParameterWrapper(Type type, uint8_t rows, uint8_t columns, void *data);
+	ParameterWrapper(Type type, uint8_t rows, uint8_t columns,
+			const void *data);
+	virtual ~ParameterWrapper();
+
+	virtual ReturnValue_t serialize(uint8_t** buffer, uint32_t* size,
+			const uint32_t max_size, bool bigEndian) const;
+
+	virtual uint32_t getSerializedSize() const;
+
+	virtual ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size,
+			bool bigEndian);
+
+	virtual ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size,
+			bool bigEndian, uint16_t startWritingAtIndex = 0);
+
+	template<typename T>
+	ReturnValue_t getElement(T *value, uint8_t row = 0, uint8_t column = 0) const {
+		if (readonlyData == NULL){
+			return NOT_SET;
+		}
+
+		if (PodTypeConversion<T>::type != type) {
+			return DATATYPE_MISSMATCH;
+		}
+
+		if ((row > rows) || (column > columns)) {
+			return OUT_OF_BOUNDS;
+		}
+
+		if (pointsToStream) {
+			const uint8_t *streamWithtype = (const uint8_t *) readonlyData;
+			streamWithtype += (row * columns + column) * type.getSize();
+			int32_t size = type.getSize();
+			return SerializeAdapter<T>::deSerialize(value, &streamWithtype,
+					&size, true);
+		} else {
+			const T *dataWithType = (const T *) readonlyData;
+			*value = dataWithType[row * columns + column];
+			return HasReturnvaluesIF::RETURN_OK;
+		}
+	}
+
+	template<typename T>
+	void set(T *data, uint8_t rows, uint8_t columns) {
+		this->data = data;
+		this->readonlyData = data;
+		this->type = PodTypeConversion<T>::type;
+		this->rows = rows;
+		this->columns = columns;
+		this->pointsToStream = false;
+	}
+
+	template<typename T>
+	void set(const T *readonlyData, uint8_t rows, uint8_t columns) {
+		this->data = NULL;
+		this->readonlyData = readonlyData;
+		this->type = PodTypeConversion<T>::type;
+		this->rows = rows;
+		this->columns = columns;
+		this->pointsToStream = false;
+	}
+
+	template<typename T>
+	void set(T& member) {
+		this->set(&member, 1, 1);
+	}
+
+	template<typename T>
+	void set(const T& readonlyMember) {
+		this->set(&readonlyMember, 1, 1);
+	}
+
+	template<typename T>
+	void setVector(T& member) {
+		this->set(member, 1, sizeof(member)/sizeof(member[0]));
+	}
+
+	template<typename T>
+	void setVector(const T& member) {
+		this->set(member, 1, sizeof(member)/sizeof(member[0]));
+	}
+	template<typename T>
+	void setMatrix(T& member) {
+		this->set(member[0], sizeof(member)/sizeof(member[0]), sizeof(member[0])/sizeof(member[0][0]));
+	}
+
+	template<typename T>
+	void setMatrix(const T& member) {
+		this->set(member[0], sizeof(member)/sizeof(member[0]), sizeof(member[0])/sizeof(member[0][0]));
+	}
+	ReturnValue_t set(const uint8_t *stream, int32_t streamSize,
+			const uint8_t **remainingStream = NULL, int32_t *remainingSize =
+					NULL);
+
+	ReturnValue_t copyFrom(const ParameterWrapper *from,
+			uint16_t startWritingAtIndex);
+
+private:
+	bool pointsToStream;
+
+	Type type;
+	uint8_t rows;
+	uint8_t columns;
+	void *data;
+	const void *readonlyData;
+
+	template<typename T>
+	ReturnValue_t serializeData(uint8_t** buffer, uint32_t* size,
+			const uint32_t max_size, bool bigEndian) const;
+
+	template<typename T>
+	ReturnValue_t deSerializeData(uint8_t startingRow, uint8_t startingColumn,
+			const void *from, uint8_t fromRows, uint8_t fromColumns);
+};
+
+#endif /* PARAMETERWRAPPER_H_ */

parameters/ReceivesParameterMessagesIF.h

@@ -0,0 +1,18 @@
+#ifndef RECEIVESPARAMETERMESSAGESIF_H_
+#define RECEIVESPARAMETERMESSAGESIF_H_
+
+
+#include <framework/ipc/MessageQueue.h>
+#include <framework/parameters/HasParametersIF.h>
+
+class ReceivesParameterMessagesIF : public HasParametersIF {
+public:
+
+	virtual ~ReceivesParameterMessagesIF() {
+	}
+
+	virtual MessageQueueId_t getCommandQueue() const = 0;
+};
+
+
+#endif /* RECEIVESPARAMETERMESSAGESIF_H_ */