Iteration.hpp

Go to the documentation of this file.

#pragma once
 
#include <cmath>
#include <cstddef>
#include <iostream>
#include <type_traits>
 
namespace volcart
{
 
template <typename T, std::enable_if_t<std::is_arithmetic<T>::value, int> = 0>
class RangeIterable
{
private:
    template <typename ItT>
    class CountingIterator
    {
    private:
        ItT value_{0};
        ItT maxValue_{1};
        ItT step_{1};
 
    public:
        using difference_type = std::size_t;
        using value_type = ItT;
        using pointer = value_type*;
        using reference = value_type const&;
        using iterator_category = std::input_iterator_tag;
        explicit CountingIterator(ItT value, ItT maxValue, ItT step)
            : value_{value}, maxValue_{maxValue}, step_{step}
        {
        }
 
        reference operator*() const { return value_; }
 
        bool operator==(const CountingIterator& other) const
        {
            return value_ == other.value_;
        }
 
        bool operator!=(const CountingIterator& other) const
        {
            return !(*this == other);
        }
 
        CountingIterator& operator++()
        {
            // Stop iterating at the max value
            if (value_ < maxValue_) {
                value_ = std::min(value_ + step_, maxValue_);
            }
            return *this;
        }
    };
 
public:
    using iterator = CountingIterator<T>;
    using const_iterator = CountingIterator<T const&>;
 
    RangeIterable(T start, T end, T step)
        : start_{start}, end_{end}, step_{step}
    {
        if (step <= 0) {
            throw std::invalid_argument("step size cannot be zero or negative");
        }
    }
 
    iterator begin() const { return iterator{start_, end_, step_}; }
    iterator end() const { return iterator{end_, end_, step_}; }
    const_iterator cbegin() const
    {
        return const_iterator{start_, end_, step_};
    }
    const_iterator cend() const { return const_iterator{end_, end_, step_}; }
 
    template <typename Q = T>
    std::enable_if_t<std::is_floating_point<Q>::value, std::size_t> size() const
    {
        return static_cast<std::size_t>(std::ceil((end_ - start_) / step_));
    }
 
    template <typename Q = T>
    std::enable_if_t<std::is_integral<Q>::value, std::size_t> size() const
    {
        return static_cast<std::size_t>((end_ - start_) / step_);
    }
 
private:
    T start_{0};
    T end_{0};
    T step_{1};
};
 
template <typename T>
std::ostream& operator<<(std::ostream& os, const RangeIterable<T>& it)
{
    for (const auto& v : it) {
        if (v != *it.begin()) {
            os << " ";
        }
        os << v;
    }
    return os;
}
 
template <typename T>
auto range(T stop)
{
    return RangeIterable<T>(0, stop, 1);
}
 
template <typename T0, typename T1>
auto range(T0 start, T1 stop)
{
    return RangeIterable<T0>(start, stop, 1);
}
 
template <typename T0, typename T1, typename T2>
auto range(T0 start, T1 stop, T2 step)
{
    return RangeIterable<T0>(start, stop, step);
}
 
template <typename T, std::enable_if_t<std::is_arithmetic<T>::value, int> = 0>
class Range2DIterable
{
private:
    template <typename ItT>
    class Counting2DIterator
    {
    private:
        ItT v_{0};
        ItT vMax_{1};
        ItT u_{0};
        ItT uStart_{0};
        ItT uMax_{1};
        ItT step_{1};
 
    public:
        using difference_type = std::size_t;
        using value_type = std::pair<ItT const&, ItT const&>;
        using pointer = value_type*;
        using reference = value_type;
        using iterator_category = std::input_iterator_tag;
        explicit Counting2DIterator(ItT v, ItT vMax, ItT u, ItT uMax, ItT step)
            : v_{v}, vMax_{vMax}, u_{u}, uStart_{u}, uMax_{uMax}, step_{step}
        {
        }
 
        reference operator*() const { return {v_, u_}; }
 
        bool operator==(const Counting2DIterator& other) const
        {
            return u_ == other.u_ and v_ == other.v_;
        }
 
        bool operator!=(const Counting2DIterator& other) const
        {
            return !(*this == other);
        }
 
        Counting2DIterator& operator++()
        {
            if (u_ < uMax_) {
                u_ = std::min(u_ + step_, uMax_);
            }
 
            if (u_ == uMax_ and v_ < vMax_) {
                v_ = std::min(v_ + step_, vMax_);
 
                if (v_ < vMax_) {
                    u_ = uStart_;
                }
            }
 
            return *this;
        }
    };
 
public:
    using iterator = Counting2DIterator<T>;
    using const_iterator = Counting2DIterator<T const&>;
 
    Range2DIterable(T vStart, T vEnd, T uStart, T uEnd, T step)
        : vStart_{vStart}
        , vEnd_{vEnd}
        , uStart_{uStart}
        , uEnd_{uEnd}
        , step_{step}
    {
        if (step <= 0) {
            throw std::invalid_argument("step size cannot be zero or negative");
        }
    }
 
    iterator begin() const
    {
        return iterator{vStart_, vEnd_, uStart_, uEnd_, step_};
    }
    iterator end() const { return iterator{vEnd_, vEnd_, uEnd_, uEnd_, step_}; }
    const_iterator cbegin() const
    {
        return const_iterator{vStart_, vEnd_, uStart_, uEnd_, step_};
    }
    const_iterator cend() const
    {
        return const_iterator{vEnd_, vEnd_, uEnd_, uEnd_, step_};
    }
 
    template <typename Q = T>
    std::enable_if_t<std::is_floating_point<Q>::value, std::size_t> size() const
    {
        auto vLen =
            static_cast<std::size_t>(std::ceil((vEnd_ - vStart_) / step_));
        return static_cast<std::size_t>(std::ceil((uEnd_ - uStart_) / step_)) *
               vLen;
    }
 
    template <typename Q = T>
    std::enable_if_t<std::is_integral<Q>::value, std::size_t> size() const
    {
        auto vLen = static_cast<std::size_t>((vEnd_ - vStart_) / step_);
        return static_cast<std::size_t>((uEnd_ - uStart_) / step_) * vLen;
    }
 
private:
    T vStart_{0};
    T vEnd_{0};
    T uStart_{0};
    T uEnd_{0};
    T step_{1};
};
 
template <typename T0, typename T1>
auto range2D(T0 vStop, T1 uStop)
{
    return Range2DIterable<T0>(0, vStop, 0, uStop, 1);
}
 
template <typename T0, typename T1, typename T2, typename T3>
auto range2D(T0 vStart, T1 vStop, T2 uStart, T3 uStop)
{
    return Range2DIterable<T0>(vStart, vStop, uStart, uStop, 1);
}
 
template <typename T0, typename T1, typename T2, typename T3, typename T4>
auto range2D(T0 vStart, T1 vStop, T2 uStart, T3 uStop, T4 step)
{
    return Range2DIterable<T0>(vStart, vStop, uStart, uStop, step);
}
 
// Predeclarations
template <class Iterable>
class EnumerateIterable;
 
template <class Iterable>
inline auto enumerate(Iterable&& it);
 
template <typename... Args>
inline EnumerateIterable<std::vector<std::common_type_t<Args...>>> enumerate(
    Args&&... args);
 
template <class Iterable>
class EnumerateIterable
{
private:
    template <class T>
    class EnumerateIterator
    {
    private:
        std::size_t idx_;
        T it_;
 
    public:
        using difference_type = std::size_t;
        using value_type =
            std::pair<std::size_t, decltype(*std::declval<T&>())&>;
        using pointer = value_type*;
        using reference = value_type;
        using iterator_category = std::input_iterator_tag;
        explicit EnumerateIterator(std::size_t idx, T&& it)
            : idx_{idx}, it_{std::move(it)}
        {
        }
 
        value_type operator*() const { return {idx_, *it_}; }
 
        bool operator==(const EnumerateIterator& other) const
        {
            return it_ == other.it_;
        }
 
        bool operator!=(const EnumerateIterator& other) const
        {
            return !(*this == other);
        }
 
        EnumerateIterator& operator++()
        {
            ++idx_;
            ++it_;
            return *this;
        }
    };
 
    using IteratorType = decltype(std::begin(std::declval<Iterable>()));
 
    EnumerateIterable(Iterable&& container)
        : container_{std::forward<Iterable>(container)}
    {
    }
 
    template <typename... Args>
    EnumerateIterable(Args&&... args) : container_{std::forward<Args>(args)...}
    {
    }
 
    friend auto enumerate<Iterable>(Iterable&& it);
 
    template <typename... Args>
    friend EnumerateIterable<std::vector<std::common_type_t<Args...>>>
    enumerate(Args&&... args);
 
public:
    using iterator = EnumerateIterator<IteratorType>;
    using const_iterator = EnumerateIterator<const IteratorType>;
 
    iterator begin() const { return iterator{0, std::begin(container_)}; }
 
    iterator end() const { return iterator{0, std::end(container_)}; }
 
    const_iterator cbegin() const
    {
        return const_iterator{0, std::begin(container_)};
    }
 
    const_iterator cend() const
    {
        return const_iterator{0, std::end(container_)};
    }
 
private:
    Iterable container_;
};
 
template <class Iterable>
inline auto enumerate(Iterable&& it)
{
    return EnumerateIterable<Iterable>(std::forward<Iterable>(it));
}
 
template <typename... Args>
inline EnumerateIterable<std::vector<std::common_type_t<Args...>>> enumerate(
    Args&&... args)
{
    using Type = std::common_type_t<Args...>;
    using Iterable = std::vector<Type>;
    return EnumerateIterable<Iterable>(std::forward<Args>(args)...);
}
 
}  // namespace volcart