fsfw/src/fsfw/container/FixedMap.h

#ifndef FSFW_CONTAINER_FIXEDMAP_H_
#define FSFW_CONTAINER_FIXEDMAP_H_

#include <type_traits>
#include <utility>

#include "../returnvalues/returnvalue.h"
#include "ArrayList.h"

namespace mapdefs {
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);
}  // namespace mapdefs

/**
 * @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:
 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) == returnvalue::OK) {
      return mapdefs::KEY_ALREADY_EXISTS;
    }
    if (_size == theMap.maxSize()) {
      return mapdefs::MAP_FULL;
    }
    theMap[_size].first = key;
    theMap[_size].second = value;
    if (storedValue != nullptr) {
      *storedValue = Iterator(&theMap[_size]);
    }
    ++_size;
    return returnvalue::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 = mapdefs::KEY_DOES_NOT_EXIST;
    if (findIndex(key) < _size) {
      result = returnvalue::OK;
    }
    return result;
  }

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

  ReturnValue_t erase(key_t key) {
    uint32_t i;
    if ((i = findIndex(key)) >= _size) {
      return mapdefs::KEY_DOES_NOT_EXIST;
    }
    theMap[i] = theMap[_size - 1];
    --_size;
    return returnvalue::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 != returnvalue::OK) {
      return end();
    }
    return Iterator(&theMap[findIndex(key)]);
  }

  ReturnValue_t find(key_t key, T** value) const {
    ReturnValue_t result = exists(key);
    if (result != returnvalue::OK) {
      return result;
    }
    *value = &theMap[findIndex(key)].second;
    return returnvalue::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 == returnvalue::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 == returnvalue::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_ */