insertion_ordered_set.h

Go to the documentation of this file.

#pragma once

#include <vector>
#include <algorithm>

#include "containers.h"


BEGIN_NAMESPACE_CONTAINERS

template <typename T>
class InsertionOrderedSet
{
public:
    using iterator = typename std::vector<T>::iterator;
    using const_iterator = typename std::vector<T>::const_iterator;

public:
    InsertionOrderedSet() = default;
    InsertionOrderedSet(std::initializer_list<T> elements);

    void insert(const T& element);
    template<class InputIt>
    void insert(InputIt first, InputIt last);
    void insert(std::initializer_list<T> elements);
    void clear();

    bool contains(const T& element) const;
    iterator find(const T& element);
    const_iterator find(const T& element) const;

    T& operator[](std::size_t index);
    const T& operator[](std::size_t index) const;
    std::size_t size() const;
    bool empty() const;

    iterator begin();
    iterator end();
    const_iterator begin() const;
    const_iterator end() const;

    bool operator==(const InsertionOrderedSet<T>& other) const;
    bool operator!=(const InsertionOrderedSet<T>& other) const;
    bool operator<(const InsertionOrderedSet<T>& other) const;

private:
    std::vector<T> elements;
};

template <typename T>
InsertionOrderedSet<T>::InsertionOrderedSet(std::initializer_list<T> elements)
{
    for (const auto& element : elements)
        insert(element);
}

template <typename T>
template <class InputIt>
void InsertionOrderedSet<T>::insert(InputIt first, InputIt last)
{
    static_assert(std::is_same<typename std::iterator_traits<InputIt>::value_type, T>::value,
                  "InsertionOrderedSet InputIt must be an iterator of type T");
    for (auto it = first; it != last; ++it)
        insert(*it);
}

template <typename T>
void InsertionOrderedSet<T>::insert(const T& element)
{
    if (!contains(element))
        elements.emplace_back(element);
}

template <typename T>
void InsertionOrderedSet<T>::insert(std::initializer_list<T> elements)
{
    for (const auto& element : elements)
        insert(element);
}

template <typename T>
void InsertionOrderedSet<T>::clear()
{
    elements.clear();
}

template <typename T>
bool InsertionOrderedSet<T>::contains(const T& element) const
{
    return std::find(elements.begin(), elements.end(), element) != elements.end();
}

template <typename T>
typename InsertionOrderedSet<T>::iterator InsertionOrderedSet<T>::find(const T& element)
{
    return std::find(elements.begin(), elements.end(), element);
}

template <typename T>
typename InsertionOrderedSet<T>::const_iterator InsertionOrderedSet<T>::find(const T& element) const
{
    return std::find(elements.begin(), elements.end(), element);
}

template <typename T>
T& InsertionOrderedSet<T>::operator[](std::size_t index)
{
    return elements[index];
}

template <typename T>
const T& InsertionOrderedSet<T>::operator[](std::size_t index) const
{
    return elements[index];
}

template <typename T>
std::size_t InsertionOrderedSet<T>::size() const
{
    return elements.size();
}

template <typename T>
bool InsertionOrderedSet<T>::empty() const
{
    return elements.empty();
}

template <typename T>
typename InsertionOrderedSet<T>::iterator InsertionOrderedSet<T>::begin()
{
    return elements.begin();
}

template <typename T>
typename InsertionOrderedSet<T>::iterator InsertionOrderedSet<T>::end()
{
    return elements.end();
}

template <typename T>
typename InsertionOrderedSet<T>::const_iterator InsertionOrderedSet<T>::begin() const
{
    return elements.begin();
}

template <typename T>
typename InsertionOrderedSet<T>::const_iterator InsertionOrderedSet<T>::end() const
{
    return elements.end();
}

template <typename T>
bool InsertionOrderedSet<T>::operator==(const InsertionOrderedSet<T>& other) const
{
    return elements == other.elements;
}

template <typename T>
bool InsertionOrderedSet<T>::operator!=(const InsertionOrderedSet<T>& other) const
{
    return !(*this == other);
}

template <typename T>
bool InsertionOrderedSet<T>::operator<(const InsertionOrderedSet<T>& other) const
{
    return elements < other.elements;
}

END_NAMESPACE_CONTAINERS