vector_with_keys.h

Go to the documentation of this file.

#pragma once

#include <vector>
#include <map>

#include "vector_with_keys_iterator.h"

BEGIN_NAMESPACE_CONTAINERS

template <typename KeyType, typename ValueType>
class VectorWithKeys
{
public:
    using iterator =
        VectorWithKeysIterators::VectorWithKeysIterator<KeyType, ValueType, VectorWithKeysIterators::ConstTypeSwitch::isNonConst>;
    using const_iterator =
        VectorWithKeysIterators::VectorWithKeysIterator<KeyType, ValueType, VectorWithKeysIterators::ConstTypeSwitch::isConst>;

public:
    VectorWithKeys();

    VectorWithKeys(const VectorWithKeys<KeyType, ValueType>& other);

    VectorWithKeys<KeyType, ValueType>& operator=(const VectorWithKeys<KeyType, ValueType>& other);

    VectorWithKeys(VectorWithKeys<KeyType, ValueType>&& other);

    VectorWithKeys<KeyType, ValueType>& operator=(VectorWithKeys<KeyType, ValueType>&& other);

    const KeyType& getKey(std::size_t pos) const;

    ValueType& operator[](std::size_t pos);

    const ValueType& operator[](std::size_t pos) const;

    ValueType& back();

    const ValueType& back() const;

    void clear();

    std::size_t size() const;

    bool empty() const;

    bool emplaceBackWithKey(const KeyType& key);

    iterator erase(iterator position);

    iterator erase(std::size_t pos);

    void swap(int32_t posA, int32_t posB);

    iterator findByKey(const KeyType& key);

    const_iterator findByKey(const KeyType& key) const;
    
    iterator begin()
    {
        using namespace VectorWithKeysIterators;
        return VectorWithKeysIterator<KeyType, ValueType, ConstTypeSwitch::isNonConst>(pairs.begin());
    }

    iterator end()
    {
        using namespace VectorWithKeysIterators;
        return VectorWithKeysIterator<KeyType, ValueType, ConstTypeSwitch::isNonConst>(pairs.end());
    }

    const_iterator begin() const
    {
        using namespace VectorWithKeysIterators;
        return VectorWithKeysIterator<KeyType, ValueType, ConstTypeSwitch::isConst>(pairs.begin());
    }

    const_iterator end() const
    {
        using namespace VectorWithKeysIterators;
        return VectorWithKeysIterator<KeyType, ValueType, ConstTypeSwitch::isConst>(pairs.end());
    }

    const_iterator cbegin() const
    {
        return begin();
    }

    const_iterator cend() const
    {
        return end();
    }

private:
    std::vector<std::pair<KeyType, ValueType>> pairs;
    std::map<KeyType, typename std::vector<std::pair<KeyType, ValueType>>::iterator> pairsMap;

    void rebuildPairMap();
};

template <typename KeyType, typename ValueType>
VectorWithKeys<KeyType, ValueType>::VectorWithKeys()
{
}

template <typename KeyType, typename ValueType>
VectorWithKeys<KeyType, ValueType>::VectorWithKeys(const VectorWithKeys<KeyType, ValueType>& other)
{
    pairs = other.pairs;
    rebuildPairMap();
}

template <typename KeyType, typename ValueType>
VectorWithKeys<KeyType, ValueType>& VectorWithKeys<KeyType, ValueType>::operator=(const VectorWithKeys<KeyType, ValueType>& other)
{
    if (this != &other)
    {
        pairs = other.pairs;
        rebuildPairMap();
    }
    return *this;
}

template <typename KeyType, typename ValueType>
VectorWithKeys<KeyType, ValueType>::VectorWithKeys(VectorWithKeys<KeyType, ValueType>&& other)
{
    pairs = std::move(other.pairs);
    rebuildPairMap();

    // Clear old map
    other.pairsMap.clear();
}

template <typename KeyType, typename ValueType>
VectorWithKeys<KeyType, ValueType>& VectorWithKeys<KeyType, ValueType>::operator=(VectorWithKeys<KeyType, ValueType>&& other)
{
    if (this != &other)
    {
        pairs = std::move(other.pairs);
        rebuildPairMap();

        // Clear old map
        other.pairsMap.clear();
    }
    return *this;
}

template <typename KeyType, typename ValueType>
const KeyType& VectorWithKeys<KeyType, ValueType>::getKey(std::size_t pos) const
{
    return pairs[pos].first;
}

template <typename KeyType, typename ValueType>
ValueType& VectorWithKeys<KeyType, ValueType>::operator[](std::size_t pos)
{
    return pairs[pos].second;
}

template <typename KeyType, typename ValueType>
const ValueType& VectorWithKeys<KeyType, ValueType>::operator[](std::size_t pos) const
{
    return pairs[pos].second;
}

template <typename KeyType, typename ValueType>
ValueType& VectorWithKeys<KeyType, ValueType>::back()
{
    return pairs.back().second;
}

template <typename KeyType, typename ValueType>
const ValueType& VectorWithKeys<KeyType, ValueType>::back() const
{
    return pairs.back().second;
}

template <typename KeyType, typename ValueType>
void VectorWithKeys<KeyType, ValueType>::clear()
{
    pairs.clear();
    pairsMap.clear();
}

template <typename KeyType, typename ValueType>
std::size_t VectorWithKeys<KeyType, ValueType>::size() const
{
    return pairs.size();
}

template <typename KeyType, typename ValueType>
bool VectorWithKeys<KeyType, ValueType>::empty() const
{
    return pairs.empty();
}

template <typename KeyType, typename ValueType>
bool VectorWithKeys<KeyType, ValueType>::emplaceBackWithKey(const KeyType& key)
{
    if (pairsMap.find(key) == pairsMap.end())
    {
        pairs.emplace_back();
        (pairs.back()).first = key;
        rebuildPairMap();
        return true;
    }
    return false;
}

template <typename KeyType, typename ValueType>
typename VectorWithKeys<KeyType, ValueType>::iterator VectorWithKeys<KeyType, ValueType>::erase(iterator position)
{
    auto it = pairs.erase(position.pointee);
    rebuildPairMap();
    return iterator(it);
}

template <typename KeyType, typename ValueType>
typename VectorWithKeys<KeyType, ValueType>::iterator VectorWithKeys<KeyType, ValueType>::erase(std::size_t pos)
{
    auto it = pairs.erase(pairs.begin() + pos);
    rebuildPairMap();
    return iterator(it);
}

template <typename KeyType, typename ValueType>
void VectorWithKeys<KeyType, ValueType>::swap(int32_t posA, int32_t posB)
{
    if (posA != posB)
    {
        std::swap(pairs[posA], pairs[posB]);
        rebuildPairMap();
    }
}

template <typename KeyType, typename ValueType>
typename VectorWithKeys<KeyType, ValueType>::iterator VectorWithKeys<KeyType, ValueType>::findByKey(const KeyType& key)
{
    auto pairsMapIter = pairsMap.find(key);

    if (pairsMapIter != pairsMap.end())
    {
        return iterator(pairsMapIter->second);
    }
    return end();
}

template <typename KeyType, typename ValueType>
typename VectorWithKeys<KeyType, ValueType>::const_iterator VectorWithKeys<KeyType, ValueType>::findByKey(const KeyType& key) const
{
    auto pairsMapIter = pairsMap.find(key);

    if (pairsMapIter != pairsMap.end())
    {
        return iterator(pairsMapIter->second);
    }
    return end();
}

template <typename KeyType, typename ValueType>
void VectorWithKeys<KeyType, ValueType>::rebuildPairMap()
{
    pairsMap.clear();
    for (auto pairIter = pairs.begin(); pairIter != pairs.end(); ++pairIter)
    {
        pairsMap.insert(std::make_pair(pairIter->first, pairIter));
    }
}

END_NAMESPACE_CONTAINERS