generic_iterator.hpp

#pragma once
 
#include <iterator>
#include <memory>
 
namespace dl::utils {
 
    template <typename T>
    class GenericIterator {
    private:
        class AIter {
        public:
            virtual ~AIter() noexcept = default;
            virtual T deref() const noexcept = 0;
            virtual void advance() noexcept = 0;
            virtual bool equals(const AIter& other) const noexcept = 0;
            virtual const std::type_info& type() const = 0;
            virtual std::unique_ptr<AIter> clone() const = 0;
        };
 
        template <std::input_or_output_iterator TIt>
        class Iter final : public AIter {
        private:
            TIt iterator;
            std::shared_ptr<void> userdata;
 
        public:
            explicit Iter(TIt& iterator) noexcept : iterator(iterator), userdata(nullptr) {}
 
            Iter(TIt& iterator, std::shared_ptr<auto> userdata) : iterator(iterator), userdata(userdata) {}
 
            T deref() const noexcept override { return *iterator; }
            void advance() noexcept override { std::ranges::advance(iterator, 1); }
            bool equals(const AIter& other) const noexcept override {
                return other.type() == type() && static_cast<const Iter<TIt>&>(other).iterator == iterator;
            }
            const std::type_info& type() const override { return typeid(this); }
            std::unique_ptr<AIter> clone() const override { return std::make_unique<Iter<TIt>>(*this); }
        };
 
        std::unique_ptr<AIter> impl;
 
    public:
        using iterator_category = std::input_iterator_tag;
        using difference_type = std::ptrdiff_t;
        using value_type = T;
        using pointer = T*;
        using reference = T&;
 
        GenericIterator() : impl(nullptr) {}
 
        GenericIterator(const GenericIterator<T>& other) : impl(other.impl->clone()) {}
 
        GenericIterator(GenericIterator<T>&& other) : impl(std::move(other.impl)) {}
 
        template <std::input_or_output_iterator TIt>
        explicit GenericIterator(TIt iterator) noexcept : impl(std::make_unique<Iter<TIt>>(iterator)) {}
 
        template <std::input_or_output_iterator TIt>
        GenericIterator(TIt iterator, std::shared_ptr<auto> userdata) noexcept
                : impl(std::make_unique<Iter<TIt>>(iterator, userdata)) {}
 
        GenericIterator<T>& operator=(const GenericIterator<T>& other) noexcept {
            impl = other.impl;
            return *this;
        }
 
        GenericIterator<T>& operator=(GenericIterator<T>&& other) noexcept {
            impl = std::move(other.impl);
            return *this;
        }
 
        T operator*() const { return impl->deref(); }
        GenericIterator<T>& operator++() noexcept {
            impl->advance();
            return *this;
        }
        GenericIterator<T> operator++(int) noexcept {
            auto copy = *this;
            (*this)++;
            return copy;
        }
        bool operator==(const GenericIterator<T>& other) const { return impl->equals(*other.impl); }
    };
 
    static_assert(std::input_iterator<GenericIterator<int>>);
} // namespace dl::utils