fsfw/container/FixedMap.h

#ifndef FSFW_CONTAINER_FIXEDMAP_H_
#define FSFW_CONTAINER_FIXEDMAP_H_

#include "ArrayList.h"
#include "../returnvalues/HasReturnvaluesIF.h"
#include <utility>
#include <type_traits>

/**
 * @brief    Map implementation for maps with a pre-defined size.
 * @details
 * Can be initialized with desired maximum size.
 * Iterator is used to access <key,value> pair and iterate through map entries.
 * Complexity O(n).
 * @warning Iterators return a non-const key_t in the pair.
 * @warning A User is not allowed to change the key, otherwise the map is corrupted.
 * @ingroup container
 */
template<typename key_t, typename T>
class FixedMap: public SerializeIF {
	static_assert (std::is_trivially_copyable<T>::value or
	        std::is_base_of<SerializeIF, T>::value,
			"Types used in FixedMap must either be trivial copy-able or a "
			"derived class from SerializeIF to be serialize-able");
public:
	static const uint8_t INTERFACE_ID = CLASS_ID::FIXED_MAP;
	static const ReturnValue_t KEY_ALREADY_EXISTS = MAKE_RETURN_CODE(0x01);
	static const ReturnValue_t MAP_FULL = MAKE_RETURN_CODE(0x02);
	static const ReturnValue_t KEY_DOES_NOT_EXIST = MAKE_RETURN_CODE(0x03);

private:
	static const key_t EMPTY_SLOT = -1;
	ArrayList<std::pair<key_t, T>, uint32_t> theMap;
	uint32_t _size;

	uint32_t findIndex(key_t key) const {
		if (_size == 0) {
			return 1;
		}
		uint32_t i = 0;
		for (i = 0; i < _size; ++i) {
			if (theMap[i].first == key) {
				return i;
			}
		}
		return i;
	}
public:
	FixedMap(uint32_t maxSize) :
			theMap(maxSize), _size(0) {
	}

	class Iterator: public ArrayList<std::pair<key_t, T>, uint32_t>::Iterator {
	public:
		Iterator() :
				ArrayList<std::pair<key_t, T>, uint32_t>::Iterator() {
		}

		Iterator(std::pair<key_t, T> *pair) :
				ArrayList<std::pair<key_t, T>, uint32_t>::Iterator(pair) {
		}
	};

	friend bool operator==(const typename FixedMap::Iterator& lhs,
			const typename FixedMap::Iterator& rhs) {
		return (lhs.value == rhs.value);
	}

	friend bool operator!=(const typename FixedMap::Iterator& lhs,
			const typename FixedMap::Iterator& rhs) {
		return not (lhs.value == rhs.value);
	}

	Iterator begin() const {
		return Iterator(&theMap[0]);
	}

	Iterator end() const {
		return Iterator(&theMap[_size]);
	}

	uint32_t size() const {
		return _size;
	}

	ReturnValue_t insert(key_t key, T value, Iterator *storedValue = nullptr) {
		if (exists(key) == HasReturnvaluesIF::RETURN_OK) {
			return KEY_ALREADY_EXISTS;
		}
		if (_size == theMap.maxSize()) {
			return MAP_FULL;
		}
		theMap[_size].first = key;
		theMap[_size].second = value;
		if (storedValue != nullptr) {
			*storedValue = Iterator(&theMap[_size]);
		}
		++_size;
		return HasReturnvaluesIF::RETURN_OK;
	}

	ReturnValue_t insert(std::pair<key_t, T> pair) {
		return insert(pair.first, pair.second);
	}

	ReturnValue_t exists(key_t key) const {
		ReturnValue_t result = KEY_DOES_NOT_EXIST;
		if (findIndex(key) < _size) {
			result = HasReturnvaluesIF::RETURN_OK;
		}
		return result;
	}

	ReturnValue_t erase(Iterator *iter) {
		uint32_t i;
		if ((i = findIndex((*iter).value->first)) >= _size) {
			return KEY_DOES_NOT_EXIST;
		}
		theMap[i] = theMap[_size - 1];
		--_size;
		--((*iter).value);
		return HasReturnvaluesIF::RETURN_OK;
	}

	ReturnValue_t erase(key_t key) {
		uint32_t i;
		if ((i = findIndex(key)) >= _size) {
			return KEY_DOES_NOT_EXIST;
		}
		theMap[i] = theMap[_size - 1];
		--_size;
		return HasReturnvaluesIF::RETURN_OK;
	}

	T *findValue(key_t key) const {
		return &theMap[findIndex(key)].second;
	}

	Iterator find(key_t key) const {
		ReturnValue_t result = exists(key);
		if (result != HasReturnvaluesIF::RETURN_OK) {
			return end();
		}
		return Iterator(&theMap[findIndex(key)]);
	}

	ReturnValue_t find(key_t key, T **value) const {
		ReturnValue_t result = exists(key);
		if (result != HasReturnvaluesIF::RETURN_OK) {
			return result;
		}
		*value = &theMap[findIndex(key)].second;
		return HasReturnvaluesIF::RETURN_OK;
	}

	bool empty() {
	    if(_size == 0) {
	        return true;
	    }
	    else {
	        return false;
	    }
	}

	bool full() {
	    if(_size >= theMap.maxSize()) {
	        return true;
	    }
	    else {
	        return false;
	    }
	}

	void clear() {
		_size = 0;
	}

	uint32_t maxSize() const {
		return theMap.maxSize();
	}

	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
			size_t maxSize, Endianness streamEndianness) const {
		ReturnValue_t result = SerializeAdapter::serialize(&this->_size,
				buffer, size, maxSize, streamEndianness);
		uint32_t i = 0;
		while ((result == HasReturnvaluesIF::RETURN_OK) && (i < this->_size)) {
			result = SerializeAdapter::serialize(&theMap[i].first, buffer,
					size, maxSize, streamEndianness);
			result = SerializeAdapter::serialize(&theMap[i].second, buffer, size,
					maxSize, streamEndianness);
			++i;
		}
		return result;
	}

	virtual size_t getSerializedSize() const {
		uint32_t printSize = sizeof(_size);
		uint32_t i = 0;

		for (i = 0; i < _size; ++i) {
			printSize += SerializeAdapter::getSerializedSize(
					&theMap[i].first);
			printSize += SerializeAdapter::getSerializedSize(&theMap[i].second);
		}

		return printSize;
	}

	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
			Endianness streamEndianness) {
		ReturnValue_t result = SerializeAdapter::deSerialize(&this->_size,
				buffer, size, streamEndianness);
		if (this->_size > theMap.maxSize()) {
			return SerializeIF::TOO_MANY_ELEMENTS;
		}
		uint32_t i = 0;
		while ((result == HasReturnvaluesIF::RETURN_OK) && (i < this->_size)) {
			result = SerializeAdapter::deSerialize(&theMap[i].first, buffer,
					size, streamEndianness);
			result = SerializeAdapter::deSerialize(&theMap[i].second, buffer, size,
					streamEndianness);
			++i;
		}
		return result;
	}

};

#endif /* FSFW_CONTAINER_FIXEDMAP_H_ */