Enumerate.hpp

#pragma once
 
#include <iterator>
#include <tuple>
#include <utility>
 
namespace PixelBullet
{
    template <typename T>
    class EnumerateWrapper
    {
    public:
        explicit EnumerateWrapper(T&& iterable)
            : iterable_(std::forward<T>(iterable))
        {
        }
 
        class iterator
        {
        public:
            using IterType = decltype(std::begin(std::declval<T&>()));
            using DifferenceType = std::ptrdiff_t;
            using ValueType = std::tuple<std::size_t, decltype(*std::begin(std::declval<T&>()))>;
            using Pointer = void;
            using Reference = ValueType;
            using IteratorCategory = std::input_iterator_tag;
 
            iterator(IterType iter, std::size_t index)
                : iter_(iter)
                , index_(index)
            {
            }
 
            iterator& operator++()
            {
                ++iter_;
                ++index_;
                return *this;
            }
 
            bool operator!=(const iterator& other) const
            {
                return iter_ != other.iter_;
            }
 
            auto operator*() const
            {
                return std::tie(index_, *iter_);
            }
 
        private:
            IterType iter_;
            std::size_t index_;
        };
 
        auto begin()
        {
            return iterator{ std::begin(iterable_), 0 };
        }
 
        auto end()
        {
            return iterator{ std::end(iterable_), 0 };
        }
 
    private:
        T iterable_;
    };
 
    template <typename T>
    auto Enumerate(T&& iterable)
    {
        return EnumerateWrapper<T>{ std::forward<T>(iterable) };
    }
} // namespace PixelBullet