FixedMap.hpp

Go to the documentation of this file.

#ifndef SOLIDUTILS_INCLUDE_FIXEDMAP_HPP
#define SOLIDUTILS_INCLUDE_FIXEDMAP_HPP


#include "Array.hpp"
#include "ConstArray.hpp"

namespace sl
{

template <typename K, typename V>
class FixedMap
{
  public:
    static constexpr K const NULL_INDEX = static_cast<K>(-1);

    FixedMap(
        size_t const size) :
      m_size(0),
      m_keys(size),
      m_values(size),
      m_index(size, NULL_INDEX)
    {
      // do nothing
    }


    bool has(
        K const key) const noexcept
    {
      size_t const index = static_cast<size_t>(key);

      ASSERT_LESS(index, m_index.size());

      return m_index[index] != NULL_INDEX;
    }


    V get(
        K const key) const noexcept
    {
      size_t const index = static_cast<size_t>(key);

      ASSERT_LESS(index, m_index.size());

      return m_values[m_index[index]];
    }

    void add(
        K const key,
        V const value) noexcept
    {
      size_t const index = static_cast<size_t>(key);

      ASSERT_LESS(index, m_index.size());
      ASSERT_EQUAL(m_index[index], NULL_INDEX);

      m_keys[m_size] = key;
      m_values[m_size] = value;

      m_index[index] = m_size;

      ++m_size;
    }


    void remove(
        K const key) noexcept
    {
      size_t const index = static_cast<size_t>(key);

      ASSERT_LESS(index, m_index.size());
      ASSERT_NOTEQUAL(m_index[index], NULL_INDEX);

      --m_size;
      K const swapKey = m_keys[m_size];
      V const swapValue = m_values[m_size];
      size_t const place = m_index[index];
      m_keys[place] = swapKey;
      m_values[place] = swapValue;
      m_index[static_cast<size_t>(swapKey)] = place;
      m_index[index] = NULL_INDEX;
    }


    size_t size() const noexcept
    {
      return m_size;
    }


    size_t maxSize() const noexcept
    {
      return m_keys.size();
    }


    ConstArray<K> keys() const noexcept
    {
      ASSERT_LESS(m_size, m_keys.size());
      return ConstArray<K>(m_keys.data(), m_size);
    }

    ConstArray<V> values() const noexcept
    {
      ASSERT_LESS(m_size, m_values.size());
      return ConstArray<V>(m_values.data(), m_size);
    }


  private:
    size_t m_size;
    Array<K> m_keys;
    Array<V> m_values;
    Array<K> m_index;
};

}


#endif