iterators.h

/*
 * AUI Framework - Declarative UI toolkit for modern C++20
 * Copyright (C) 2020-2024 Alex2772 and Contributors
 *
 * SPDX-License-Identifier: MPL-2.0
 *
 * This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/.
 */
 
#pragma once
 
#include <tuple>
#include <variant>
#include <cstdint>
#include <iterator>
#include <ostream>
#include "parameter_pack.h"
#include "macros.h"
 
 
namespace aui {
 
    template <typename T>
    struct reverse_iterator_wrap {
    private:
        const T& mIterable;
 
    public:
        reverse_iterator_wrap(const T& mIterable) : mIterable(mIterable) {}
 
        auto begin() {
            return mIterable.rbegin();
        }
        auto end() {
            return mIterable.rend();
        }
    };
 
    template<typename Iterator>
    struct range {
    private:
        Iterator mBegin;
        Iterator mEnd;
    public:
        constexpr range(Iterator mBegin, Iterator mEnd) : mBegin(mBegin), mEnd(mEnd) {}
 
        constexpr ~range() {
            AUI_NO_OPTIMIZE_OUT(range::size)
        }
 
        template<typename Container>
        constexpr range(Container& c): mBegin(c.begin()), mEnd(c.end()) {
 
        }
 
 
        template<typename Container>
        constexpr range(const Container& c): mBegin(c.begin()), mEnd(c.end()) {
 
        }
 
        [[nodiscard]]
        constexpr bool empty() const noexcept {
            return mBegin == mEnd;
        }
 
        [[nodiscard]]
        constexpr std::size_t size() const noexcept {
            return std::distance(mBegin, mEnd);
        }
 
        [[nodiscard]]
        constexpr Iterator& begin() noexcept {
            return mBegin;
        }
 
        [[nodiscard]]
        constexpr Iterator& end() noexcept {
            return mEnd;
        }
 
        [[nodiscard]]
        constexpr Iterator begin() const noexcept {
            return mBegin;
        }
 
        [[nodiscard]]
        constexpr Iterator end() const noexcept {
            return mEnd;
        }
 
        [[nodiscard]]
        constexpr const auto& first() const {
            return *mBegin;
        }
 
        [[nodiscard]]
        constexpr const auto& last() const {
            return *std::prev(mEnd);
        }
 
        [[nodiscard]]
        constexpr bool operator==(const range& rhs) const noexcept;
 
        [[nodiscard]]
        constexpr bool operator!=(const range& rhs) const noexcept {
            return !(*this == rhs);
        }
    };
 
    template<typename Container>
    range(Container& c) -> range<decltype(c.begin())>;
 
    template<typename Container>
    range(const Container& c) -> range<decltype(c.begin())>;
 
    template<typename Container>
    using const_iterator_if_const = std::conditional_t<std::is_const_v<Container>,
                                                       typename Container::const_iterator,
                                                       typename Container::iterator>;
 
 
    template<typename... Containers>
    struct zip {
    private:
        using iterator_parallel = std::tuple<decltype(std::declval<Containers>().begin())...>;
 
        iterator_parallel begins_;
        iterator_parallel ends_;
 
    public:
        struct iterator {
            iterator_parallel iterators_;
 
            iterator(iterator_parallel iterators) : iterators_(std::move(iterators)) {}
 
            iterator& operator++() noexcept {
                std::apply([](auto&&... v) {
                    (++v, ...);
                }, iterators_);
                return *this;
            }
 
            std::tuple<decltype(*std::declval<Containers>().begin())&...> operator*() noexcept {
                return std::apply([](auto&&... v) {
                    return std::tuple<decltype(*std::declval<Containers>().begin())&...>((*v)...);
                }, iterators_);
            }
 
            bool operator==(const iterator& rhs) const noexcept {
                return iterators_ == rhs.iterators_;
            }
 
            bool operator!=(const iterator& rhs) const noexcept {
                return iterators_ != rhs.iterators_;
            }
        };
 
        zip(Containers&... c): begins_(c.begin()...), ends_(c.end()...) {
 
        }
 
        iterator begin() noexcept {
            return iterator(begins_);
        }
        iterator end() noexcept {
            return iterator(ends_);
        }
    };
 
    namespace impl {
        template<typename Iterator, class = void>
        static constexpr bool is_forward_iterator = true;
 
        template<typename Iterator>
        static constexpr bool is_forward_iterator<std::reverse_iterator<Iterator>> = false;
    }
 
    template<typename Iterator>
    auto reverse_iterator_direction(Iterator iterator) noexcept ->
        std::enable_if_t<!impl::is_forward_iterator<Iterator>,
                         decltype((iterator + 1).base())
                         > {
        return (iterator + 1).base();
    }
 
    template<typename Iterator>
    auto reverse_iterator_direction(Iterator iterator) noexcept ->
        std::enable_if_t<impl::is_forward_iterator<Iterator>,
                         decltype(std::make_reverse_iterator(std::declval<Iterator>()))
                         > {
 
        return std::make_reverse_iterator(iterator + 1);
    }
}
 
template<typename Iterator>
inline constexpr bool aui::range<Iterator>::operator==(const range& rhs) const noexcept {
    if (size() != rhs.size()) {
        return false;
    }
    for (const auto&[l, r] : aui::zip(*this, rhs)) {
        if (l != r) {
            return false;
        }
    }
    return true;
}
 
template<typename T>
inline std::ostream& operator<<(std::ostream& os, aui::range<T> range) {
    os << "[ ";
    bool isFirst = true;
    for (const auto& v : range) {
        if (isFirst) {
            isFirst = false;
        } else {
            os << ", ";
        }
        os << v;
    }
    return os << " ]";
}