FixedSet.hpp

Go to the documentation of this file.

#ifndef SOLIDUTILS_INCLUDE_FIXEDSET_HPP
#define SOLIDUTILS_INCLUDE_FIXEDSET_HPP


#include "Array.hpp"


namespace sl
{


template <typename T>
class FixedSet
{
  public:
    static constexpr T const NULL_INDEX = static_cast<T>(-1);

    FixedSet(
        size_t const size) :
      m_size(0),
      m_data(size),
      m_index(size, NULL_INDEX)
    {
      // do nothing
    }


    bool has(
        T const element) const noexcept
    {
      size_t const index = static_cast<size_t>(element);

      ASSERT_LESS(index, m_index.size());

      return m_index[index] != NULL_INDEX;
    }

    void add(
        T const element) noexcept
    {
      size_t const index = static_cast<size_t>(element);

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

      m_data[m_size] = element;
      m_index[index] = m_size;

      ++m_size;
    }


    void remove(
        T const element) noexcept
    {
      size_t const index = static_cast<size_t>(element);

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

      --m_size;
      T const swap = m_data[m_size];
      size_t const place = m_index[index];
      m_data[place] = swap;
      m_index[swap] = place;
      m_index[index] = NULL_INDEX;
    }


    T * data() noexcept
    {
      return m_data.data();
    }


    T const * data() const noexcept
    {
      return m_data.data();
    }


    size_t size() const noexcept
    {
      return m_size;
    }


    T const * begin() const noexcept
    {
      return m_data.begin();
    }


    T const * end() const noexcept
    {
      // we want to return the set's size, and not the array's.
      return m_data.begin() + m_size;
    }


    T * begin() noexcept
    {
      return m_data.begin();
    }


    T * end() noexcept
    {
      // we want to return the set's size, and not the array's.
      return m_data.begin() + m_size;
    }


  private:
    size_t m_size;
    Array<T> m_data;
    Array<T> m_index;
};

}

#endif