vector_with_keys_iterator.h

Go to the documentation of this file.

#pragma once

#include "containers.h"

BEGIN_NAMESPACE_CONTAINERS

// Forward declaration
template <typename KeyType, typename ValueType>
class VectorWithKeys;

namespace VectorWithKeysIterators
{
enum class ConstTypeSwitch
{
    isConst = 0,
    isNonConst = 1
};

template <typename KeyType, typename ValueType, ConstTypeSwitch ConstSwitch>
struct UnderlyingTypes
{
    using ValType = ValueType;
    using PointeeType = typename std::vector<std::pair<KeyType, ValueType>>::iterator;
};

template <typename KeyType, typename ValueType>
struct UnderlyingTypes<KeyType, ValueType, ConstTypeSwitch::isConst>
{
    using ValType = const ValueType;
    using PointeeType = typename std::vector<std::pair<KeyType, ValueType>>::const_iterator;
};

template <typename KeyType, typename ValueType>
struct UnderlyingTypes<KeyType, ValueType, ConstTypeSwitch::isNonConst>
{
    using ValType = ValueType;
    using PointeeType = typename std::vector<std::pair<KeyType, ValueType>>::iterator;
};

template <typename KeyType, typename ValueType, ConstTypeSwitch ConstSwitch>
class VectorWithKeysIterator
{
    friend class VectorWithKeys<KeyType, ValueType>;

public:
    using ValType = typename UnderlyingTypes<KeyType, ValueType, ConstSwitch>::ValType;
    using PointeeType = typename UnderlyingTypes<KeyType, ValueType, ConstSwitch>::PointeeType;

    using iterator_category = std::forward_iterator_tag;
    using value_type = ValType;
    using difference_type = std::ptrdiff_t;
    using pointer = ValType*;
    using reference = ValType&;

public:

    const KeyType& getKey() const;

    ValType& operator*();

    ValType* operator->();

    const VectorWithKeysIterator<KeyType, ValueType, ConstSwitch>& operator++();

    VectorWithKeysIterator<KeyType, ValueType, ConstSwitch> operator++(int32_t);

    VectorWithKeysIterator<KeyType, ValueType, ConstSwitch> operator+(int32_t increment);

    bool operator==(const VectorWithKeysIterator<KeyType, ValueType, ConstSwitch>& other) const;

    bool operator!=(const VectorWithKeysIterator<KeyType, ValueType, ConstSwitch>& other) const;

private:
    PointeeType pointee;
    VectorWithKeysIterator(PointeeType pointee)
        : pointee(pointee)
    {
    }
};

template <typename KeyType, typename ValueType, ConstTypeSwitch ConstSwitch>
const KeyType& VectorWithKeysIterator<KeyType, ValueType, ConstSwitch>::getKey() const
{
    return pointee->first;
}

template <typename KeyType, typename ValueType, ConstTypeSwitch ConstSwitch>
typename VectorWithKeysIterator<KeyType, ValueType, ConstSwitch>::ValType& VectorWithKeysIterator<KeyType, ValueType, ConstSwitch>::
operator*()
{
    return pointee->second;
}

template <typename KeyType, typename ValueType, ConstTypeSwitch ConstSwitch>
typename VectorWithKeysIterator<KeyType, ValueType, ConstSwitch>::ValType* VectorWithKeysIterator<KeyType, ValueType, ConstSwitch>::
operator->()
{
    return &(pointee->second);
}

template <typename KeyType, typename ValueType, ConstTypeSwitch ConstSwitch>
const VectorWithKeysIterator<KeyType, ValueType, ConstSwitch>& VectorWithKeysIterator<KeyType, ValueType, ConstSwitch>::operator++()
{
    ++pointee;
    return *this;
}

template <typename KeyType, typename ValueType, ConstTypeSwitch ConstSwitch>
VectorWithKeysIterator<KeyType, ValueType, ConstSwitch> VectorWithKeysIterator<KeyType, ValueType, ConstSwitch>::operator++(int32_t)
{
    VectorWithKeysIterator<KeyType, ValueType, ConstSwitch> previousState(pointee);
    ++pointee;
    return previousState;
}

template <typename KeyType, typename ValueType, ConstTypeSwitch ConstSwitch>
VectorWithKeysIterator<KeyType, ValueType, ConstSwitch> VectorWithKeysIterator<KeyType, ValueType, ConstSwitch>::operator+(int32_t increment)
{
    return VectorWithKeysIterator<KeyType, ValueType, ConstSwitch>(pointee + increment);
}

template <typename KeyType, typename ValueType, ConstTypeSwitch ConstSwitch>
bool VectorWithKeysIterator<KeyType, ValueType, ConstSwitch>::operator==(
    const VectorWithKeysIterator<KeyType, ValueType, ConstSwitch>& other) const
{
    return pointee == other.pointee;
}

template <typename KeyType, typename ValueType, ConstTypeSwitch ConstSwitch>
bool VectorWithKeysIterator<KeyType, ValueType, ConstSwitch>::operator!=(
    const VectorWithKeysIterator<KeyType, ValueType, ConstSwitch>& other) const
{
    return pointee != other.pointee;
}

}  // namespace VectorWithKeysIterators

END_NAMESPACE_CONTAINERS