enumerate.h

#pragma once
 
#include <cstddef>
#include <iterator>
#include <tuple>
#include <type_traits>
#include <utility>
 
namespace pixelbullet
{
template <typename T>
class EnumerateWrapper
{
public:
    explicit EnumerateWrapper(T&& iterable)
        : iterable_(std::forward<T>(iterable))
    {
    }
 
    template <typename IterType>
    class Iterator
    {
    public:
        using iterator_category = std::input_iterator_tag;
        using difference_type = std::ptrdiff_t;
        using element_reference = decltype(*std::declval<IterType&>());
        using value_type = std::tuple<std::size_t, std::remove_cvref_t<element_reference>>;
        using pointer = void;
        using reference = std::tuple<std::size_t, element_reference>;
 
        Iterator(IterType iter, const std::size_t index)
            : iter_(iter)
            , index_(index)
        {
        }
 
        Iterator& operator++()
        {
            ++iter_;
            ++index_;
            return *this;
        }
 
        Iterator operator++(int)
        {
            Iterator previous = *this;
            ++(*this);
            return previous;
        }
 
        bool operator==(const Iterator& other) const
        {
            return iter_ == other.iter_;
        }
 
        bool operator!=(const Iterator& other) const
        {
            return !(*this == other);
        }
 
        reference operator*() const
        {
            return reference{ index_, *iter_ };
        }
 
    private:
        IterType iter_;
        std::size_t index_;
    };
 
    auto begin()
    {
        return Iterator<decltype(std::begin(iterable_))>{ std::begin(iterable_), 0 };
    }
 
    auto end()
    {
        return Iterator<decltype(std::end(iterable_))>{ std::end(iterable_), 0 };
    }
 
    auto begin() const
    {
        return Iterator<decltype(std::begin(iterable_))>{ std::begin(iterable_), 0 };
    }
 
    auto end() const
    {
        return Iterator<decltype(std::end(iterable_))>{ std::end(iterable_), 0 };
    }
 
private:
    T iterable_;
};
 
template <typename T>
auto enumerate(T&& iterable)
{
    return EnumerateWrapper<T>{ std::forward<T>(iterable) };
}
} // namespace pixelbullet