randomAccessIterator.h

Go to the documentation of this file.

#ifndef RANDOMACCESSITERATOR_H
#define RANDOMACCESSITERATOR_H
 
#include "container.h"
#include "error.h"
#include "iterator.h"
#include <limits>
 
namespace original {
 
    template<typename TYPE, typename ALLOC>
    class randomAccessIterator : public baseIterator<TYPE> {
    protected:
        mutable TYPE* _ptr;             
        mutable const container<TYPE, ALLOC>* _container; 
        mutable integer _pos;           
 
        explicit randomAccessIterator(TYPE* ptr, const container<TYPE, ALLOC>* container, integer pos);
 
        bool equalPtr(const iterator<TYPE>* other) const override;
 
    public:
 
        randomAccessIterator(const randomAccessIterator& other);
 
        randomAccessIterator& operator=(const randomAccessIterator& other);
 
        randomAccessIterator* 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;
 
        randomAccessIterator* getNext() const override;
 
        randomAccessIterator* 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, typename ALLOC>
    original::randomAccessIterator<TYPE, ALLOC>::randomAccessIterator(TYPE* ptr, const container<TYPE, ALLOC>* container,
                                                               const integer pos)
        : _ptr{ptr}, _container{container}, _pos(pos) {}
 
    template<typename TYPE, typename ALLOC>
    auto original::randomAccessIterator<TYPE, ALLOC>::equalPtr(const iterator<TYPE> *other) const -> bool {
        auto* other_it = dynamic_cast<const randomAccessIterator*>(other);
        return other_it != nullptr && _ptr == other_it->_ptr;
    }
 
    template<typename TYPE, typename ALLOC>
    original::randomAccessIterator<TYPE, ALLOC>::randomAccessIterator(const randomAccessIterator &other) : _pos(0) {
        this->operator=(other);
    }
 
    template<typename TYPE, typename ALLOC>
    auto original::randomAccessIterator<TYPE, ALLOC>::operator=(
        const randomAccessIterator &other) -> randomAccessIterator& {
        if (this == &other) {
            return *this;
        }
        this->_ptr = other._ptr;
        this->_container = other._container;
        this->_pos = other._pos;
        return *this;
    }
 
    template<typename TYPE, typename ALLOC>
    auto original::randomAccessIterator<TYPE, ALLOC>::clone() const -> randomAccessIterator* {
        return new randomAccessIterator{_ptr, _container, _pos};
    }
 
    template<typename TYPE, typename ALLOC>
    auto original::randomAccessIterator<TYPE, ALLOC>::hasNext() const -> bool {
        return this->isValid() && this->_pos <= this->_container->size() - 1;
    }
 
    template<typename TYPE, typename ALLOC>
    auto original::randomAccessIterator<TYPE, ALLOC>::hasPrev() const -> bool {
        return this->isValid() && this->_pos >= 1;
    }
 
    template<typename TYPE, typename ALLOC>
    auto original::randomAccessIterator<TYPE, ALLOC>::atPrev(const iterator<TYPE>*) const -> bool {
        throw unSupportedMethodError();
    }
 
    template<typename TYPE, typename ALLOC>
    auto original::randomAccessIterator<TYPE, ALLOC>::atNext(const iterator<TYPE>*) const -> bool {
        throw unSupportedMethodError();
    }
 
    template<typename TYPE, typename ALLOC>
    auto original::randomAccessIterator<TYPE, ALLOC>::next() const -> void {
        ++this->_pos;
        ++this->_ptr;
    }
 
    template<typename TYPE, typename ALLOC>
    auto original::randomAccessIterator<TYPE, ALLOC>::prev() const -> void {
        --this->_pos;
        --this->_ptr;
    }
 
    template<typename TYPE, typename ALLOC>
    auto original::randomAccessIterator<TYPE, ALLOC>::operator+=(integer steps) const -> void {
        this->_pos += steps;
        this->_ptr += steps;
    }
 
    template<typename TYPE, typename ALLOC>
    auto original::randomAccessIterator<TYPE, ALLOC>::operator-=(integer steps) const -> void {
        this->_pos -= steps;
        this->_ptr -= steps;
    }
 
    template<typename TYPE, typename ALLOC>
    auto original::randomAccessIterator<TYPE, ALLOC>::operator-(const iterator<TYPE>& other) const -> integer
    {
        auto* other_it = dynamic_cast<const randomAccessIterator*>(&other);
        if (other_it == nullptr)
            return this > &other ?
                (std::numeric_limits<integer>::max)() :
                (std::numeric_limits<integer>::min)();
        if (this->_container != other_it->_container)
            return this->_container > other_it->_container ?
                (std::numeric_limits<integer>::max)() :
                (std::numeric_limits<integer>::min)();
        return this->_ptr - other_it->_ptr;
    }
 
    template<typename TYPE, typename ALLOC>
    auto original::randomAccessIterator<TYPE, ALLOC>::getNext() const -> randomAccessIterator* {
        if (!this->isValid()) throw outOfBoundError();
        auto it = this->clone();
        it->next();
        return it;
    }
 
    template<typename TYPE, typename ALLOC>
    auto original::randomAccessIterator<TYPE, ALLOC>::getPrev() const -> randomAccessIterator* {
        if (!this->isValid()) throw outOfBoundError();
        auto it = this->clone();
        it->prev();
        return it;
    }
 
    template<typename TYPE, typename ALLOC>
    auto original::randomAccessIterator<TYPE, ALLOC>::get() -> TYPE& {
        if (!this->isValid()) throw outOfBoundError();
        return *this->_ptr;
    }
 
    template<typename TYPE, typename ALLOC>
    auto original::randomAccessIterator<TYPE, ALLOC>::set(const TYPE& data) -> void {
        if (!this->isValid()) throw outOfBoundError();
        if constexpr (std::is_copy_assignable_v<TYPE>) {
            *this->_ptr = data;
        } else if constexpr (std::is_move_assignable_v<TYPE>) {
            *this->_ptr = std::move(const_cast<TYPE&>(data));
        } else {
            staticError<unSupportedMethodError, !std::is_copy_constructible_v<TYPE> && !std::is_move_constructible_v<TYPE>>::asserts();
        }
    }
 
    template<typename TYPE, typename ALLOC>
    auto original::randomAccessIterator<TYPE, ALLOC>::get() const -> TYPE
    {
        if (!this->isValid()) throw outOfBoundError();
        if constexpr (std::is_copy_constructible_v<TYPE>) {
            return *this->_ptr;
        } else if constexpr (std::is_move_constructible_v<TYPE>) {
            return std::move(*this->_ptr);
        } else {
            staticError<unSupportedMethodError, !std::is_copy_constructible_v<TYPE> && !std::is_move_constructible_v<TYPE>>::asserts();
            return TYPE{};
        }
    }
 
    template<typename TYPE, typename ALLOC>
    auto original::randomAccessIterator<TYPE, ALLOC>::isValid() const -> bool {
        return this->_pos >= 0 && this->_pos < this->_container->size();
    }
 
    template<typename TYPE, typename ALLOC>
    auto original::randomAccessIterator<TYPE, ALLOC>::className() const -> std::string {
        return "RandomAccessIterator";
    }
 
#endif //RANDOMACCESSITERATOR_H