enumerate.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <cstddef>
#include <iterator>
#include <utility>
 
namespace py {
 
    namespace detail {
 
        template <typename T> struct EnumerateIterator {
            using TIter = decltype(std::begin(std::declval<T>()));
            using iter_ref = typename std::iterator_traits<TIter>::reference;
 
            size_t i;
            TIter iter;
 
            auto operator!=(const EnumerateIterator& other) const -> bool {
                return iter != other.iter;
            }
 
            EnumerateIterator& operator++() {
                ++i;
                ++iter;
                return *this;
            }
 
            auto operator*() -> std::pair<size_t, iter_ref> {
                return std::pair<size_t, iter_ref>{i, *iter};
            }
        };
 
        template <typename T> struct EnumerateIterableWrapper {
            T& iterable;
 
            auto begin() const -> EnumerateIterator<T> {
                return EnumerateIterator<T>{0, std::begin(iterable)};
            }
 
            auto end() const -> EnumerateIterator<T> {
                return EnumerateIterator<T>{0, std::end(iterable)};
            }
        };
 
    }  // namespace detail
 
    template <typename T> inline auto enumerate(T& iterable)
        -> detail::EnumerateIterableWrapper<T> {
        return detail::EnumerateIterableWrapper<T>{iterable};
    }
 
    template <typename T> inline auto enumerate(const T& iterable)
        -> detail::EnumerateIterableWrapper<const T> {
        return detail::EnumerateIterableWrapper<const T>{iterable};
    }
 
    template <typename T> inline auto const_enumerate(const T& iterable)
        -> detail::EnumerateIterableWrapper<const T> {
        return detail::EnumerateIterableWrapper<const T>{iterable};
    }
}  // namespace py