Today's the day. Renamed platform to framework.

subsystem/modes/HasModeSequenceIF.h

@@ -0,0 +1,20 @@
+#ifndef HASMODESEQUENCEIF_H_
+#define HASMODESEQUENCEIF_H_
+
+#include <framework/subsystem/modes/ModeDefinitions.h>
+#include <framework/subsystem/modes/ModeSequenceMessage.h>
+#include <framework/subsystem/modes/ModeStoreIF.h>
+
+
+class HasModeSequenceIF {
+public:
+	virtual ~HasModeSequenceIF() {
+
+	}
+
+	virtual MessageQueueId_t getSequenceCommandQueue() const = 0;
+
+};
+
+
+#endif /* HASMODESEQUENCEIF_H_ */

subsystem/modes/ModeDefinitions.h

@@ -0,0 +1,134 @@
+/*
+ * ModeTable.h
+ *
+ *  Created on: 12.07.2013
+ *      Author: tod
+ */
+
+#ifndef MODEDEFINITIONS_H_
+#define MODEDEFINITIONS_H_
+
+#include <framework/modes/HasModesIF.h>
+#include <framework/objectmanager/SystemObjectIF.h>
+#include <framework/serialize/SerializeIF.h>
+#include <framework/serialize/SerialLinkedListAdapter.h>
+class ModeListEntry: public SerializeIF, public LinkedElement<ModeListEntry> {
+public:
+	ModeListEntry() :
+			LinkedElement<ModeListEntry>(this), value1(0), value2(0), value3(0) {
+
+	}
+
+	uint32_t value1;
+	uint32_t value2;
+	uint8_t value3;
+
+	virtual ReturnValue_t serialize(uint8_t** buffer, uint32_t* size,
+			const uint32_t max_size, bool bigEndian) const {
+
+		ReturnValue_t result;
+
+		result = SerializeAdapter<uint32_t>::serialize(&value1, buffer, size,
+				max_size, bigEndian);
+
+		if (result != HasReturnvaluesIF::RETURN_OK) {
+			return result;
+		}
+		result = SerializeAdapter<uint32_t>::serialize(&value2, buffer, size,
+				max_size, bigEndian);
+
+		if (result != HasReturnvaluesIF::RETURN_OK) {
+			return result;
+		}
+		result = SerializeAdapter<uint8_t>::serialize(&value3, buffer, size,
+				max_size, bigEndian);
+
+		return result;
+
+	}
+
+	virtual uint32_t getSerializedSize() const {
+		return sizeof(value1) + sizeof(value2) + sizeof(value3);
+	}
+
+	virtual ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size,
+			bool bigEndian) {
+		ReturnValue_t result;
+
+		result = SerializeAdapter<uint32_t>::deSerialize(&value1, buffer, size,
+				bigEndian);
+
+		if (result != HasReturnvaluesIF::RETURN_OK) {
+			return result;
+		}
+		result = SerializeAdapter<uint32_t>::deSerialize(&value2, buffer, size,
+				bigEndian);
+
+		if (result != HasReturnvaluesIF::RETURN_OK) {
+			return result;
+		}
+		result = SerializeAdapter<uint8_t>::deSerialize(&value3, buffer, size,
+				bigEndian);
+
+		return result;
+	}
+
+	//for Sequences
+	Mode_t getTableId() const {
+		return value1;
+	}
+
+	void setTableId(Mode_t tableId) {
+		this->value1 = tableId;
+	}
+
+	uint8_t getWaitSeconds() const {
+		return value2;
+	}
+
+	void setWaitSeconds(uint8_t waitSeconds) {
+		this->value2 = waitSeconds;
+	}
+
+	bool checkSuccess() const {
+		return value3 == 1;
+	}
+
+	void setCheckSuccess(bool checkSuccess) {
+		this->value3 = checkSuccess;
+	}
+
+
+	//for Tables
+	object_id_t getObject() const {
+		return value1;
+	}
+
+	void setObject(object_id_t object) {
+		this->value1 = object;
+	}
+
+	//TODO no cast!
+	Mode_t getMode() const {
+		return value2;
+	}
+
+	void setMode(Mode_t mode) {
+		this->value2 = mode;
+	}
+
+	Submode_t getSubmode() const {
+		return value3;
+	}
+
+	void setSubmode(Submode_t submode) {
+		this->value3 = submode;
+	}
+
+	bool operator==(ModeListEntry other) {
+		return ((value1 == other.value1) && (value2 == other.value2)
+				&& (value3 == other.value3));
+	}
+};
+
+#endif //MODEDEFINITIONS_H_

subsystem/modes/ModeSequenceMessage.cpp

@@ -0,0 +1,89 @@
+#include <framework/objectmanager/ObjectManagerIF.h>
+#include <framework/objectmanager/ObjectManagerIF.h>
+#include <framework/objectmanager/ObjectManagerIF.h>
+#include <framework/storagemanager/StorageManagerIF.h>
+#include <framework/subsystem/modes/ModeSequenceMessage.h>
+
+void ModeSequenceMessage::setModeSequenceMessage(CommandMessage* message,
+		Command_t command, Mode_t sequence, store_address_t storeAddress) {
+	message->setCommand(command);
+	message->setParameter(storeAddress.raw);
+	message->setParameter2(sequence);
+}
+
+//void ModeSequenceMessage::setModeSequenceMessage(CommandMessage* message,
+//		Command_t command, ModeTableId_t table, store_address_t storeAddress) {
+//	message->setCommand(command);
+//	message->setParameter(storeAddress.raw);
+//	message->setParameter2(table);
+//}
+
+void ModeSequenceMessage::setModeSequenceMessage(CommandMessage* message,
+		Command_t command, Mode_t sequence) {
+	message->setCommand(command);
+	message->setParameter2(sequence);
+}
+
+//void ModeSequenceMessage::setModeSequenceMessage(CommandMessage* message,
+//		Command_t command, ModeTableId_t table) {
+//	message->setCommand(command);
+//	message->setParameter2(table);
+//}
+
+void ModeSequenceMessage::setModeSequenceMessage(CommandMessage* message,
+		Command_t command, store_address_t storeAddress) {
+	message->setCommand(command);
+	message->setParameter(storeAddress.raw);
+}
+
+store_address_t ModeSequenceMessage::getStoreAddress(
+		const CommandMessage* message) {
+	store_address_t address;
+	address.raw = message->getParameter();
+	return address;
+}
+
+Mode_t ModeSequenceMessage::getSequenceId(const CommandMessage* message) {
+	return message->getParameter2();
+}
+
+Mode_t ModeSequenceMessage::getTableId(const CommandMessage* message) {
+	return message->getParameter2();
+}
+
+
+uint32_t ModeSequenceMessage::getNumber(const CommandMessage* message) {
+	return message->getParameter2();
+}
+
+void ModeSequenceMessage::clear(CommandMessage *message) {
+	switch (message->getCommand()) {
+	case ADD_SEQUENCE:
+	case ADD_TABLE:
+	case SEQUENCE_LIST:
+	case TABLE_LIST:
+	case TABLE:
+	case SEQUENCE:{
+		StorageManagerIF *ipcStore = objectManager->get<StorageManagerIF>(objects::IPC_STORE);
+		if (ipcStore != NULL){
+			ipcStore->deleteData(ModeSequenceMessage::getStoreAddress(message));
+		}
+	}
+		/*NO BREAK*/
+	case DELETE_SEQUENCE:
+	case DELETE_TABLE:
+	case READ_SEQUENCE:
+	case READ_TABLE:
+	case LIST_SEQUENCES:
+	case LIST_TABLES:
+	case READ_FREE_SEQUENCE_SLOTS:
+	case FREE_SEQUENCE_SLOTS:
+	case READ_FREE_TABLE_SLOTS:
+	case FREE_TABLE_SLOTS:
+	default:
+		message->setCommand(CommandMessage::CMD_NONE);
+		message->setParameter(0);
+		message->setParameter2(0);
+		break;
+	}
+}

subsystem/modes/ModeSequenceMessage.h

@@ -0,0 +1,48 @@
+#ifndef MODESEQUENCEMESSAGE_H_
+#define MODESEQUENCEMESSAGE_H_
+
+#include <framework/ipc/CommandMessage.h>
+#include <framework/storagemanager/StorageManagerIF.h>
+#include <framework/subsystem/modes/ModeDefinitions.h>
+
+class ModeSequenceMessage {
+public:
+	static const uint8_t MESSAGE_ID = MODE_SEQUENCE_MESSAGE_ID;
+
+	static const Command_t ADD_SEQUENCE = MAKE_COMMAND_ID(0x01);
+	static const Command_t ADD_TABLE = MAKE_COMMAND_ID(0x02);
+	static const Command_t DELETE_SEQUENCE = MAKE_COMMAND_ID(0x03);
+	static const Command_t DELETE_TABLE = MAKE_COMMAND_ID(0x04);
+	static const Command_t READ_SEQUENCE = MAKE_COMMAND_ID(0x05);
+	static const Command_t READ_TABLE = MAKE_COMMAND_ID(0x06);
+	static const Command_t LIST_SEQUENCES = MAKE_COMMAND_ID(0x07);
+	static const Command_t LIST_TABLES = MAKE_COMMAND_ID(0x08);
+	static const Command_t SEQUENCE_LIST = MAKE_COMMAND_ID(0x09);
+	static const Command_t TABLE_LIST = MAKE_COMMAND_ID(0x0A);
+	static const Command_t TABLE = MAKE_COMMAND_ID(0x0B);
+	static const Command_t SEQUENCE = MAKE_COMMAND_ID(0x0C);
+	static const Command_t READ_FREE_SEQUENCE_SLOTS = MAKE_COMMAND_ID(0x0D);
+	static const Command_t FREE_SEQUENCE_SLOTS = MAKE_COMMAND_ID(0x0E);
+	static const Command_t READ_FREE_TABLE_SLOTS = MAKE_COMMAND_ID(0x0F);
+	static const Command_t FREE_TABLE_SLOTS = MAKE_COMMAND_ID(0x10);
+
+	static void setModeSequenceMessage(CommandMessage *message,
+			Command_t command, Mode_t sequenceOrTable,
+			store_address_t storeAddress);
+	static void setModeSequenceMessage(CommandMessage *message,
+			Command_t command, Mode_t sequenceOrTable);
+	static void setModeSequenceMessage(CommandMessage *message,
+			Command_t command, store_address_t storeAddress);
+
+	static store_address_t getStoreAddress(const CommandMessage *message);
+	static Mode_t getSequenceId(const CommandMessage *message);
+	static Mode_t getTableId(const CommandMessage *message);
+	static uint32_t getNumber(const CommandMessage *message);
+
+	static void clear(CommandMessage *message);
+
+private:
+	ModeSequenceMessage();
+};
+
+#endif /* MODESEQUENCEMESSAGE_H_ */

subsystem/modes/ModeStore.cpp

@@ -0,0 +1,122 @@
+#include <framework/subsystem/modes/ModeStore.h>
+
+ModeStore::ModeStore(object_id_t objectId, uint32_t slots) :
+		SystemObject(objectId), store(slots), emptySlot(store.front()) {
+	mutex = new MutexId_t;
+	OSAL::createMutex(objectId + 1, mutex);
+	clear();
+}
+
+ModeStore::~ModeStore() {
+	delete mutex;
+}
+
+uint32_t ModeStore::getFreeSlots() {
+	OSAL::lockMutex(mutex, OSAL::NO_TIMEOUT);
+	uint32_t count = 0;
+	ArrayList<ModeListEntry, uint32_t>::Iterator iter;
+	for (iter = store.begin(); iter != store.end(); ++iter) {
+		if (iter->getNext() == emptySlot) {
+			++count;
+		}
+	}
+	OSAL::unlockMutex(mutex);
+	return count;
+}
+
+ReturnValue_t ModeStore::storeArray(ArrayList<ModeListEntry>* sequence,
+		ModeListEntry** storedFirstEntry) {
+	if (sequence->size == 0) {
+		return CANT_STORE_EMPTY;
+	}
+	OSAL::lockMutex(mutex, OSAL::NO_TIMEOUT);
+	*storedFirstEntry = findEmptySlotNoLock(store.front());
+
+	ModeListEntry* pointer =
+			*storedFirstEntry;
+	pointer->setNext(pointer);
+
+	ArrayList<ModeListEntry>::Iterator iter;
+	for (iter = sequence->begin(); iter != sequence->end(); ++iter) {
+		//TODO: I need to check this in detail. What is the idea? Why does it not work?
+		pointer = pointer->getNext()->value;
+		if (pointer == NULL) {
+			deleteListNoLock(*storedFirstEntry);
+			OSAL::unlockMutex(mutex);
+			return TOO_MANY_ELEMENTS;
+		}
+		pointer->value->value1 = iter->value1;
+		pointer->value->value2 = iter->value2;
+		pointer->value->value3 = iter->value3;
+		pointer->setNext(findEmptySlotNoLock(pointer + 1));
+	}
+	pointer->setNext(NULL);
+	OSAL::unlockMutex(mutex);
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t ModeStore::deleteList(ModeListEntry* sequence) {
+	ReturnValue_t result = isValidEntry(sequence);
+		if (result != HasReturnvaluesIF::RETURN_OK) {
+			return result;
+		}
+		OSAL::lockMutex(mutex, OSAL::NO_TIMEOUT);
+		deleteListNoLock(sequence);
+		OSAL::unlockMutex(mutex);
+		return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t ModeStore::readList(ModeListEntry* sequence,
+		ArrayList<ModeListEntry>* into) {
+	ReturnValue_t result = isValidEntry(sequence);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+	OSAL::lockMutex(mutex, OSAL::NO_TIMEOUT);
+	result = into->insert(*sequence->value);
+	while ((result == HasReturnvaluesIF::RETURN_OK) && (sequence->getNext() != NULL)) {
+		result = into->insert(*sequence->value);
+		sequence = sequence->getNext()->value;
+	}
+	OSAL::unlockMutex(mutex);
+	return result;
+}
+
+void ModeStore::clear() {
+	OSAL::lockMutex(mutex, OSAL::NO_TIMEOUT);
+	store.size = store.maxSize();
+	ArrayList<ModeListEntry, uint32_t>::Iterator iter;
+	for (iter = store.begin(); iter != store.end(); ++iter) {
+		iter->setNext(emptySlot);
+	}
+	OSAL::unlockMutex(mutex);
+}
+
+ModeListEntry* ModeStore::findEmptySlotNoLock(ModeListEntry* startFrom) {
+	ArrayList<ModeListEntry, uint32_t>::Iterator iter(
+			startFrom);
+	for (; iter != store.end(); ++iter) {
+		if (iter.value->getNext() == emptySlot) {
+			OSAL::unlockMutex(mutex);
+			return iter.value;
+		}
+	}
+	return NULL;
+}
+
+void ModeStore::deleteListNoLock(ModeListEntry* sequence) {
+	ModeListEntry* next = sequence;
+	while (next != NULL) {
+		next = sequence->getNext()->value;
+		sequence->setNext(emptySlot);
+		sequence = next;
+	}
+}
+
+ReturnValue_t ModeStore::isValidEntry(ModeListEntry* sequence) {
+	if ((sequence < store.front()) || (sequence > store.back())
+			|| sequence->getNext() == emptySlot) {
+		return INVALID_ENTRY;
+	}
+	return HasReturnvaluesIF::RETURN_OK;
+}

subsystem/modes/ModeStore.h

@@ -0,0 +1,41 @@
+#ifndef MODESTORE_H_
+#define MODESTORE_H_
+
+#include <framework/container/ArrayList.h>
+#include <framework/container/SinglyLinkedList.h>
+#include <framework/objectmanager/SystemObject.h>
+#include <framework/subsystem/modes/ModeStoreIF.h>
+
+class ModeStore: public ModeStoreIF, public SystemObject {
+public:
+	ModeStore(object_id_t objectId, uint32_t slots);
+	virtual ~ModeStore();
+
+	virtual ReturnValue_t storeArray(ArrayList<ModeListEntry> *sequence,
+			ModeListEntry **storedFirstEntry);
+
+	virtual ReturnValue_t deleteList(
+			ModeListEntry *sequence);
+
+	virtual ReturnValue_t readList(
+			ModeListEntry *sequence,
+			ArrayList<ModeListEntry> *into);
+
+	virtual uint32_t getFreeSlots();
+
+private:
+	MutexId_t* mutex;
+	ArrayList<ModeListEntry, uint32_t> store;
+	ModeListEntry *emptySlot;
+
+	void clear();
+	ModeListEntry* findEmptySlotNoLock(
+			ModeListEntry* startFrom);
+	void deleteListNoLock(
+			ModeListEntry *sequence);
+
+	ReturnValue_t isValidEntry(ModeListEntry *sequence);
+};
+
+#endif /* MODESTORE_H_ */
+

subsystem/modes/ModeStoreIF.h

@@ -0,0 +1,33 @@
+#ifndef MODESTOREIF_H_
+#define MODESTOREIF_H_
+
+#include <framework/container/ArrayList.h>
+#include <framework/container/SinglyLinkedList.h>
+#include <framework/returnvalues/HasReturnvaluesIF.h>
+#include <framework/subsystem/modes/ModeDefinitions.h>
+
+class ModeStoreIF {
+public:
+	static const uint8_t INTERFACE_ID = MODE_STORE_IF;
+	static const ReturnValue_t INVALID_ENTRY = MAKE_RETURN_CODE(0x02);
+	static const ReturnValue_t TOO_MANY_ELEMENTS = MAKE_RETURN_CODE(0x03);
+	static const ReturnValue_t CANT_STORE_EMPTY = MAKE_RETURN_CODE(0x04);
+
+	virtual ~ModeStoreIF() {
+
+	}
+
+	virtual ReturnValue_t storeArray(ArrayList<ModeListEntry> *sequence,
+			ModeListEntry **storedFirstEntry) = 0;
+
+	virtual ReturnValue_t deleteList(
+			ModeListEntry *sequence) = 0;
+
+	virtual ReturnValue_t readList(
+			ModeListEntry *sequence,
+			ArrayList<ModeListEntry> *into) = 0;
+
+	virtual uint32_t getFreeSlots() = 0;
+};
+
+#endif /* MODESTOREIF_H_ */