vector_with_ids_iterator.h

Go to the documentation of this file.

#pragma once

#include <vector>

#include "containers.h"

BEGIN_NAMESPACE_CONTAINERS

// Forward declaration
template <typename T>
class VectorWithIds;

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

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

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

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

template <typename T, ConstTypeSwitch ConstSwitch>
class VectorWithIdsIterator
{
    friend class VectorWithIds<T>;

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

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

public:

    int32_t getId() const;

    ValueType& operator*();

    ValueType* operator->();

    const VectorWithIdsIterator<T, ConstSwitch>& operator++();

    VectorWithIdsIterator<T, ConstSwitch> operator++(int32_t);

    VectorWithIdsIterator<T, ConstSwitch> operator+(int32_t increment);

    bool operator==(const VectorWithIdsIterator<T, ConstSwitch>& other) const;

    bool operator!=(const VectorWithIdsIterator<T, ConstSwitch>& other) const;

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

template <typename T, ConstTypeSwitch ConstSwitch>
int32_t VectorWithIdsIterator<T, ConstSwitch>::getId() const
{
    return pointee->first;
}

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

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

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

template <typename T, ConstTypeSwitch ConstSwitch>
VectorWithIdsIterator<T, ConstSwitch> VectorWithIdsIterator<T, ConstSwitch>::operator++(int32_t)
{
    VectorWithIdsIterator<T, ConstSwitch> previousState(pointee);
    ++pointee;
    return previousState;
}

template <typename T, ConstTypeSwitch ConstSwitch>
VectorWithIdsIterator<T, ConstSwitch> VectorWithIdsIterator<T, ConstSwitch>::operator+(int32_t increment)
{
    return VectorWithIdsIterator<T, ConstSwitch>(pointee + increment);
}

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

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

}  // namespace VectorWithIdsIterators

END_NAMESPACE_CONTAINERS