ArrayIt.h

#pragma once


#include <libutl/RandIt.h>


UTL_NS_BEGIN;



class ArrayIt : public RandIt
{
    UTL_CLASS_DECL(ArrayIt, RandIt);

public:
    ArrayIt(const Array* array, size_t offset)
        : _array(const_cast<Array*>(array))
        , _offset(offset)
    {
        IFDEBUG(FwdIt::setOwner(_array));
    }

    virtual int compare(const Object& rhs) const;

    virtual void copy(const Object& rhs);

    virtual void forward(size_t dist = 1);

    virtual Object*
    get() const
    {
        if (_offset >= _array->totalSize()) return nullptr;
        return _array->get(_offset);
    }

    virtual Object*
    get(size_t offset) const
    {
        ASSERTD(!_array->hasHole());
        return _array->get(offset);
    }

    Array*
    getArray() const
    {
        return _array;
    }

    virtual size_t offset() const;

    virtual void reverse(size_t dist = 1);

    virtual void
    seek(size_t offset)
    {
        ASSERTD(!_array->hasHole());
        _offset = offset;
    }

    virtual void set(const Object* object);

    virtual void
    set(size_t offset, const Object* object)
    {
        ASSERTD(!isConst());
        _array->set(offset, object);
    }

    virtual size_t
    size() const
    {
        return _array->size();
    }

    virtual size_t subtract(const RandIt& it) const;

    ArrayIt operator+(size_t dist) const
    {
        ArrayIt res = *this;
        res.forward(dist);
        return res;
    }

    ArrayIt operator-(size_t dist) const
    {
        ArrayIt res = *this;
        res.reverse(dist);
        return res;
    }

    size_t operator-(const ArrayIt& it) const
    {
        return subtract(it);
    }

    ArrayIt& operator++()
    {
        forward();
        return *this;
    }

    ArrayIt operator++(int)
    {
        ArrayIt res = *this;
        forward();
        return res;
    }

    ArrayIt& operator--()
    {
        reverse();
        return *this;
    }

    ArrayIt operator--(int)
    {
        ArrayIt res = *this;
        reverse();
        return res;
    }

private:
    void
    init()
    {
        _array = nullptr;
        _offset = size_t_max;
    }
    void
    deInit()
    {
    }

private:
    Array* _array;
    size_t _offset;
};


RandIt*
Array::beginNew() const
{
    auto it = new base_iterator(this, 0);
    IFDEBUG(it->setConst(true));
    return it;
}


RandIt*
Array::beginNew()
{
    return new base_iterator(this, 0);
}


RandIt*
Array::endNew() const
{
    auto it = new base_iterator(this, size_t_max);
    IFDEBUG(it->setConst(true));
    return it;
}


RandIt*
Array::endNew()
{
    return new base_iterator(this, size_t_max);
}


UTL_NS_END;