Enumerate.hpp

Go to the documentation of this file.

//
//  CeresEngine - A game development framework
//
//  Created by Rogiel Sulzbach.
//  Copyright (c) 2018-2022 Rogiel Sulzbach. All rights reserved.
//
 
#pragma once
 
#include "CeresEngine/Foundation/Iterator.hpp"
 
#include <functional>
#include <iterator>
 
namespace CeresEngine {
 
    template<typename Iterator, typename Index = std::size_t> class EnumerateIterator {
    private:
        Index mIndex = 0;
 
        Iterator mIterator;
 
    public:
        using iterator_category = typename std::iterator_traits<Iterator>::iterator_category;
        using value_type = typename std::iterator_traits<Iterator>::value_type;
        using difference_type = typename std::iterator_traits<Iterator>::difference_type;
        using pointer = typename std::iterator_traits<Iterator>::pointer;
        using reference = typename std::iterator_traits<Iterator>::reference;
 
        EnumerateIterator(Index index, Iterator&& iterator) : mIndex(index), mIterator(std::forward<Iterator>(iterator)) {}
 
        EnumerateIterator& operator++() {
            ++mIndex;
            ++mIterator;
            return *this;
        }
 
        EnumerateIterator operator++(int) {
            EnumerateIterator copy = *this;
            mIndex++;
            mIterator++;
            return copy;
        }
 
        EnumerateIterator& operator+(difference_type offset) {
            mIndex += offset;
            mIterator += offset;
            return *this;
        }
 
        EnumerateIterator& operator--() {
            --mIndex;
            --mIterator;
            return *this;
        }
 
        EnumerateIterator operator--(int) {
            EnumerateIterator copy = *this;
            mIndex++;
            mIterator++;
            return copy;
        }
 
        EnumerateIterator& operator-(difference_type offset) {
            mIndex -= offset;
            mIterator -= offset;
            return *this;
        }
 
        auto operator*() const noexcept {
            if constexpr(std::is_lvalue_reference_v<decltype(*mIterator)> || std::is_rvalue_reference_v<decltype(*mIterator)>) {
                return std::make_pair(mIndex, std::ref(*mIterator));
            } else {
                return std::make_pair(mIndex, *mIterator);
            }
        }
 
        auto* operator->() const noexcept { return &**this; }
 
        bool operator==(const EnumerateIterator& other) const { return mIterator == other.mIterator; }
        bool operator!=(const EnumerateIterator& other) const { return mIterator != other.mIterator; }
        bool operator>(const EnumerateIterator& other) const { return mIterator > other.mIterator; }
        bool operator>=(const EnumerateIterator& other) const { return mIterator >= other.mIterator; }
        bool operator<(const EnumerateIterator& other) const { return mIterator < other.mIterator; }
        bool operator<=(const EnumerateIterator& other) const { return mIterator <= other.mIterator; }
    };
 
    template<typename Index = std::size_t, typename Range> inline auto enumerate(Range& range, Index startingAt = 0) {
        return wrap(EnumerateIterator(startingAt, std::begin(range)), EnumerateIterator(~Index(0), std::end(range)));
    }
 
    template<typename Index = std::size_t, typename Range> inline auto enumerate(Range&& range, Index startingAt = 0) {
        using Iterator = std::decay_t<decltype(std::begin(range))>;
        return wrap(EnumerateIterator<Iterator, Index>(startingAt, std::begin(range)), EnumerateIterator<Iterator, Index>(~Index(0), std::end(range)),
            std::forward<Range>(range));
    }
 
} // namespace CeresEngine