iterators.hpp

Go to the documentation of this file.

/* 
 * This file is part of PLaSK (https://plask.app) by Photonics Group at TUL
 * Copyright (c) 2022 Lodz University of Technology
 * 
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, version 3.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 */
#ifndef PLASK__UTILS_ITERATORS_H
#define PLASK__UTILS_ITERATORS_H
 
//general iterators utils
 
#include <boost/iterator/iterator_facade.hpp>
#include <type_traits>
#include <memory>
 
namespace plask {
 
template <typename ValueT, typename ReferenceT = ValueT&>
struct PolymorphicForwardIteratorImpl {
 
    // some typedefs compatible with stl:
 
    typedef ValueT value_type;
 
    typedef ReferenceT reference;
 
    virtual ReferenceT dereference() const = 0;
 
    virtual void increment() = 0;
 
    virtual ~PolymorphicForwardIteratorImpl() {}
 
    virtual bool equal(const PolymorphicForwardIteratorImpl& other) const = 0;
 
    /*
     * Move iterator @a distanse steps forward. By default call increment @a distanse times.
     * @param distanse how many steps
     */
    /*virtual void advance(std::size_t distanse) {
        while (distanse) { increment(); --distanse; }
    }*/
 
    virtual std::unique_ptr<PolymorphicForwardIteratorImpl<ValueT, ReferenceT>> clone() const = 0;
};
 
template <typename ValueT, typename ReferenceT = ValueT&>
struct PolymorphicForwardIteratorWithIndexImpl: public PolymorphicForwardIteratorImpl<ValueT, ReferenceT> {
 
    virtual std::size_t getIndex() const = 0;
};
 
template <typename wrapped_iterator_type, typename ValueT, typename ReferenceT = ValueT&>
struct PolymorphicForwardIteratorWrapperImpl: public PolymorphicForwardIteratorImpl<ValueT, ReferenceT> {
 
    wrapped_iterator_type wrapped_iterator;
 
    PolymorphicForwardIteratorWrapperImpl(wrapped_iterator_type wrapped_iterator): wrapped_iterator(std::move(wrapped_iterator)) {}
 
    ReferenceT dereference() const override { return *wrapped_iterator; }
 
    void increment() override { ++wrapped_iterator; }
 
    bool equal(const PolymorphicForwardIteratorImpl<ValueT, ReferenceT>& other) const override {
        return wrapped_iterator == static_cast<const PolymorphicForwardIteratorWrapperImpl<wrapped_iterator_type, ValueT, ReferenceT>&>(other).wrapped_iterator;
    }
 
    std::unique_ptr<PolymorphicForwardIteratorImpl<ValueT, ReferenceT>> clone() const override {
        return std::unique_ptr<PolymorphicForwardIteratorImpl<ValueT, ReferenceT>>(
                new PolymorphicForwardIteratorWrapperImpl<wrapped_iterator_type, ValueT, ReferenceT>(wrapped_iterator));
    }
 
};
 
template <typename ImplT>
struct PolymorphicForwardIterator:
    public boost::iterator_facade<
        PolymorphicForwardIterator<ImplT>,
        typename ImplT::value_type,
        boost::forward_traversal_tag,
        typename ImplT::reference
    > {
 
    protected:
    std::unique_ptr<ImplT> impl;
 
    public:
 
    PolymorphicForwardIterator(ImplT* impl = nullptr): impl(impl) {}
 
    PolymorphicForwardIterator(const PolymorphicForwardIterator& src) { impl = src.impl ? src.impl->clone() : nullptr; }
 
    PolymorphicForwardIterator(PolymorphicForwardIterator&& src) = default;
 
    void swap(PolymorphicForwardIterator & to_swap) noexcept { std::swap(this->impl, to_swap.impl); }
 
    PolymorphicForwardIterator& operator=(const PolymorphicForwardIterator &src) {
        this->impl = src.impl->clone();
        return *this;
    }
 
    PolymorphicForwardIterator& operator=(PolymorphicForwardIterator &&src) = default;
 
 
    private: //--- methods used by boost::iterator_facade: ---
    friend class boost::iterator_core_access;
    template <class> friend struct PolymorphicForwardIterator;
 
    bool equal(const PolymorphicForwardIterator<ImplT>& other) const {
        return impl->equal(*other.impl);
    }
 
    void increment() {
        impl->increment();
    }
 
    typename ImplT::reference dereference() const { return impl->dereference(); }
 
    //TODO use advance?
};
 
template <typename ImplT>
struct PolymorphicForwardIteratorWithIndex: public PolymorphicForwardIterator<ImplT> {
 
    PolymorphicForwardIteratorWithIndex(ImplT* impl = nullptr): PolymorphicForwardIterator<ImplT>(impl) {}
 
    std::size_t getIndex() const {
        return this->impl->getIndex();
    }
};
 
 
template <typename ContainerType, typename Reference>
inline Reference dereferenceByIndexOperator(ContainerType& container, std::size_t index) { return container[index]; }
 
template <
    typename ContainerType,
    typename Reference = decltype(std::declval<ContainerType>()[0]),
    Reference (*dereference_f)(ContainerType& container, std::size_t index) = dereferenceByIndexOperator<ContainerType, Reference>>
struct IndexedIterator: public boost::iterator_facade< IndexedIterator<ContainerType, Reference, dereference_f>, typename std::remove_reference<Reference>::type, boost::random_access_traversal_tag, Reference > {
 
    ContainerType* container;
 
    std::size_t index;
 
    IndexedIterator() {}
 
    IndexedIterator(ContainerType* container, std::size_t index): container(container), index(index) {}
 
    std::size_t getIndex() const { return index; }
 
    private: //--- methods used by boost::iterator_facade: ---
    friend class boost::iterator_core_access;
 
    template <typename OtherT>
    bool equal(const OtherT& other) const {
        return index == other.index;
    }
 
    void increment() { ++index; }
 
    void decrement() { --index; }
 
    void advance(std::ptrdiff_t to_add) { index = size_t(index + to_add); }
 
    template <typename OtherT>
    std::ptrdiff_t distance_to(OtherT z) const { return std::ptrdiff_t(z.index) - std::ptrdiff_t(index); }
 
    Reference dereference() const { return dereference_f(*container, index); }
 
};
 
template <typename ContainerType>
inline IndexedIterator<ContainerType> makeIndexedIterator(ContainerType* c, std::size_t index) {
    return IndexedIterator<ContainerType>(c, index);
}
 
template <typename FunctorType,
    typename Reference = decltype(std::declval<FunctorType>()(0)),
    typename Value = typename std::remove_reference<Reference>::type>
struct FunctorIndexedIterator: public boost::iterator_facade< FunctorIndexedIterator<FunctorType, Reference, Value>, Value, boost::random_access_traversal_tag, Reference > {
 
    FunctorType functor;
 
    std::size_t index;
 
    FunctorIndexedIterator(FunctorType functor, std::size_t index): functor(functor), index(index) {}
 
    std::size_t getIndex() const { return index; }
 
    private: //--- methods used by boost::iterator_facade: ---
    friend class boost::iterator_core_access;
    template <class, class, class> friend struct FunctorIndexedIterator;
 
    template <typename OtherT>
    bool equal(const OtherT& other) const {
        return index == other.index;
    }
 
    void increment() { ++index; }
 
    void decrement() { --index; }
 
    void advance(std::ptrdiff_t to_add) { index += to_add; }
 
    template <typename OtherT>
    std::ptrdiff_t distance_to(OtherT z) const { return z.index - index; }
 
    Reference dereference() const { return functor(index); }
 
};
 
template <
    typename ContainerType,
    typename ReturnedType,
    ReturnedType (ContainerType::*Method)(std::size_t),
    typename Reference = ReturnedType,
    typename Value = typename std::remove_reference<Reference>::type>
struct MethodIterator: public boost::iterator_facade< MethodIterator<ContainerType, ReturnedType, Method, Value, Reference>, Value, boost::random_access_traversal_tag, Reference > {
 
    ContainerType* container;
 
    std::size_t index;
 
    MethodIterator() {}
 
    MethodIterator(ContainerType* container, std::size_t index): container(container), index(index) {}
 
    std::size_t getIndex() const { return index; }
 
    private: //--- methods used by boost::iterator_facade: ---
    friend class boost::iterator_core_access;
    template <
        typename _ContainerType,
        typename _ReturnedType,
        _ReturnedType(_ContainerType::*_Method)(std::size_t),
        typename _Reference,
        typename _Value>
    friend struct MethodIterator;
 
    template <typename OtherT>
    bool equal(const OtherT& other) const {
        return index == other.index;
    }
 
    void increment() { ++index; }
 
    void decrement() { --index; }
 
    void advance(std::ptrdiff_t to_add) { index += to_add; }
 
    template <typename OtherT>
    std::ptrdiff_t distance_to(OtherT z) const { return z.index - index; }
 
    Reference dereference() const { return (container->*Method)(index); }
 
};
 
template <typename Functor>
inline FunctorIndexedIterator<Functor> makeFunctorIndexedIterator(Functor f, std::size_t index) {
    return FunctorIndexedIterator<Functor>(f, index);
}
 
template <typename ContainerType>
struct ReindexedContainer {
 
    ContainerType& originalContainer;
 
    int firstIndex, delta;
 
    ReindexedContainer(ContainerType& originalContainer, int firstIndex = 0, int delta = 1)
    : originalContainer(originalContainer), firstIndex(firstIndex), delta(delta) {}
 
    auto operator[](const std::size_t& this_index) -> decltype(originalContainer[0]) {
        return originalContainer[firstIndex + this_index * delta];
    }
 
    auto operator[](const std::size_t& this_index) const -> decltype(const_cast<const ContainerType&>(originalContainer)[0])  {
        return originalContainer[firstIndex + this_index * delta];
    }
 
};
 
template <typename ContainerType>
ReindexedContainer<ContainerType> reindexContainer(ContainerType& originalContainer, int firstIndex = 0, int delta = 1) {
    return ReindexedContainer<ContainerType>(originalContainer, firstIndex, delta);
}
 
}       // namespace plask
 
#endif