stepIterator.h

Go to the documentation of this file.

#ifndef STEPITERATOR_H
#define STEPITERATOR_H
 
#include <limits>
 
#include "iterator.h"
#include "wrapper.h"
#include "error.h"
#include "maths.h"

 
namespace original
{
    template<typename TYPE>
    class stepIterator : public baseIterator<TYPE>
    {
    protected:
        mutable wrapper<TYPE>* _ptr;  

        explicit stepIterator(wrapper<TYPE>* ptr);

        static integer ptrDistance(const stepIterator* start, const stepIterator* end);

        bool equalPtr(const iterator<TYPE>* other) const override;
 
    public:
        stepIterator(const stepIterator& other);

        stepIterator& operator=(const stepIterator& other);

        stepIterator* clone() const override;

        [[nodiscard]] bool hasNext() const override;

        [[nodiscard]] bool hasPrev() const override;

        bool atPrev(const iterator<TYPE>* other) const override;

        bool atNext(const iterator<TYPE>* other) const override;

        void next() const override;

        void prev() const override;

        void operator+=(integer steps) const override;

        void operator-=(integer steps) const override;

        integer operator-(const iterator<TYPE>& other) const override;

        stepIterator* getNext() const override;

        iterator<TYPE>* getPrev() const override;

        TYPE& get() override;

        TYPE get() const override;

        void set(const TYPE& data) override;

        [[nodiscard]] bool isValid() const override;

        [[nodiscard]] std::string className() const override;
    };
}
 
    template <typename TYPE>
    original::stepIterator<TYPE>::stepIterator(wrapper<TYPE>* ptr)
        : _ptr(ptr) {}
 
    template <typename TYPE>
    auto original::stepIterator<TYPE>::ptrDistance(const stepIterator* start, const stepIterator* end) -> integer
    {
        auto* s = start->clone();
        auto* e = end->clone();
        integer dis = 0;
        while (s->isValid()){
            if (s->_ptr == e->_ptr){
                delete s;
                delete e;
                return dis;
            }
            dis += 1;
            s->next();
        }
        if (e->isValid()){
            dis = std::numeric_limits<integer>::max();
        }
        delete s;
        delete e;
        return dis;
    }
 
    template<typename TYPE>
    auto original::stepIterator<TYPE>::equalPtr(const iterator<TYPE> *other) const -> bool {
        auto* other_it = dynamic_cast<const stepIterator*>(other);
        return other_it != nullptr && _ptr == other_it->_ptr;
    }
 
    template <typename TYPE>
    original::stepIterator<TYPE>::stepIterator(const stepIterator& other)
        : _ptr(nullptr)
    {
        this->operator=(other);
    }
 
    template <typename TYPE>
    auto original::stepIterator<TYPE>::operator=(
        const stepIterator& other) -> stepIterator&
    {
        if (this == &other) {
            return *this;
        }
        this->_ptr = other._ptr;
        return *this;
    }
 
    template<typename TYPE>
    auto original::stepIterator<TYPE>::clone() const -> stepIterator* {
        return new stepIterator(*this);
    }
 
    template <typename TYPE>
    auto original::stepIterator<TYPE>::hasNext() const -> bool
    {
        return this->isValid();
    }
 
    template<typename TYPE>
    auto original::stepIterator<TYPE>::hasPrev() const -> bool {
        throw unSupportedMethodError();
    }
 
    template <typename TYPE>
    auto original::stepIterator<TYPE>::atPrev(const iterator<TYPE>*) const -> bool
    {
        throw unSupportedMethodError();
    }
 
    template <typename TYPE>
    auto original::stepIterator<TYPE>::atNext(const iterator<TYPE>*) const -> bool
    {
        throw unSupportedMethodError();
    }
 
    template <typename TYPE>
    void original::stepIterator<TYPE>::next() const
    {
        if (!this->isValid()) throw nullPointerError();
        this->_ptr = this->_ptr->getPNext();
    }
 
    template<typename TYPE>
    auto original::stepIterator<TYPE>::prev() const -> void {
        throw unSupportedMethodError();
    }
 
    template <typename TYPE>
    auto original::stepIterator<TYPE>::operator+=(const integer steps) const -> void
    {
        if (steps < 0) {
            this->operator-=(original::abs(steps));
            return;
        }
 
        for (integer i = 0; i < steps; i++)
        {
            this->next();
        }
    }
 
    template <typename TYPE>
    auto original::stepIterator<TYPE>::operator-=(const integer steps) const -> void
    {
        if (steps < 0) {
            this->operator+=(original::abs(steps));
            return;
        }
 
        for (integer i = 0; i < steps; i++)
        {
            this->prev();
        }
    }
 
    template <typename TYPE>
    auto original::stepIterator<TYPE>::operator-(const iterator<TYPE>& other) const -> integer
    {
        auto* other_it = dynamic_cast<const stepIterator*>(&other);
        if (other_it == nullptr)
            return this > &other ?
                std::numeric_limits<integer>::max() :
                std::numeric_limits<integer>::min();
        if (const integer pos_dis = ptrDistance(other_it, this);
            pos_dis != std::numeric_limits<integer>::max()) return pos_dis;
        if (const integer neg_dis = ptrDistance(this, other_it);
            neg_dis != std::numeric_limits<integer>::max()) return -neg_dis;
        return this->_ptr > other_it->_ptr ?
            std::numeric_limits<integer>::max() :
            std::numeric_limits<integer>::min();
    }
 
    template <typename TYPE>
    auto original::stepIterator<TYPE>::getNext() const -> stepIterator* {
        return new stepIterator(this->_ptr->getPNext());
    }
 
    template<typename TYPE>
    auto original::stepIterator<TYPE>::getPrev() const -> iterator<TYPE>* {
        throw unSupportedMethodError();
    }
 
    template <typename TYPE>
    auto original::stepIterator<TYPE>::get() -> TYPE&
    {
        if (!this->isValid()) throw nullPointerError();
        return this->_ptr->getVal();
    }
 
    template <typename TYPE>
    auto original::stepIterator<TYPE>::get() const -> TYPE
    {
        if (!this->isValid()) throw nullPointerError();
        return this->_ptr->getVal();
    }
 
    template <typename TYPE>
    auto original::stepIterator<TYPE>::set(const TYPE& data) -> void
    {
        if (!this->isValid()) throw nullPointerError();
        this->_ptr->setVal(data);
    }
 
    template <typename TYPE>
    auto original::stepIterator<TYPE>::isValid() const -> bool
    {
        return this->_ptr != nullptr;
    }
 
    template <typename TYPE>
    auto original::stepIterator<TYPE>::className() const -> std::string
    {
        return "stepIterator";
    }
 
#endif //STEPITERATOR_H