PolymorphicIterator.hpp

Go to the documentation of this file.

 
 
#ifndef UTIL_SERIALIZATION_POLYMORPHICITERATOR_HPP_
#define UTIL_SERIALIZATION_POLYMORPHICITERATOR_HPP_
 
#include <memory>
 
namespace util::serialization
{
    template <typename T>
    class PolymorphicIterator {
      public:
        using value_type = T;
        using reference = value_type &;
        using pointer = value_type *;
        using difference_type = std::ptrdiff_t;
        using iterator_category = std::random_access_iterator_tag;
 
      private:
        struct Concept {
            virtual ~Concept() noexcept = default;
 
            virtual void nextInplace() = 0;
 
            [[nodiscard]] virtual value_type get() const = 0;
 
            [[nodiscard]] virtual bool equal(const Concept *other) const = 0;
 
            [[nodiscard]] virtual std::unique_ptr<Concept> clone() const = 0;
 
            [[nodiscard]] virtual const std::type_info &type() const noexcept = 0;
 
            [[nodiscard]] virtual const Concept *address() const noexcept = 0;
        };
 
        template <class Iter>
        class Model : public Concept {
          public:
            Model(Iter iter) : _iter(iter)
            {
            }
 
            void nextInplace() override final
            {
                ++_iter;
            }
 
            [[nodiscard]] value_type get() const override final
            {
                return *_iter;
            }
 
            [[nodiscard]] bool equal(const Concept *other) const override final
            {
                return _iter == dynamic_cast<const Model *>(other)->_iter;
            }
 
            [[nodiscard]] std::unique_ptr<Concept> clone() const override final
            {
                return std::make_unique<Model>(*this);
            }
 
            [[nodiscard]] const std::type_info &type() const noexcept override final
            {
                return typeid(_iter);
            }
 
            [[nodiscard]] const Concept *address() const noexcept override final
            {
                return this;
            }
 
          private:
            Iter _iter;
        };
 
      public:
        template <class Iter>
        PolymorphicIterator(Iter iter) : _impl(std::make_unique<Model<Iter>>(iter))
        {
        }
 
        PolymorphicIterator(const PolymorphicIterator &r) : _impl(r._impl->clone())
        {
        }
 
        [[nodiscard]] value_type operator*() const
        {
            return _impl->get();
        }
 
        PolymorphicIterator &operator++()
        {
            _impl->nextInplace();
            return *this;
        }
 
        [[nodiscard]] PolymorphicIterator operator++(int)
        {
            PolymorphicIterator res = *this;
 
            return ++res;
        }
 
        [[nodiscard]] bool operator==(const PolymorphicIterator &r) const noexcept
        {
            return _impl->type() == r._impl->type() && _impl->equal(r._impl->address());
        }
 
        [[nodiscard]] bool operator!=(const PolymorphicIterator &r) const noexcept
        {
            return !(*this == r);
        }
 
      private:
        std::unique_ptr<Concept> _impl;
    };
} // namespace util::serialization
 
#endif /* !UTIL_SERIALIZATION_POLYMORPHICITERATOR_HPP_ */