FwdIt.h

#pragma once


#include <libutl/FlagsMI.h>


UTL_NS_BEGIN;



class FwdIt : public Object, protected FlagsMI
{
    UTL_CLASS_DECL_ABC(FwdIt, Object);

public:
    virtual int compare(const Object& rhs) const;

    virtual void copy(const Object& rhs);

    virtual void forward(size_t dist = 1) = 0;

    virtual Object* get() const = 0;

    bool
    isConst() const
    {
        return getFlag(flg_const);
    }

    void
    setConst(bool p_const)
    {
        setFlag(flg_const, p_const);
    }

    virtual bool
    isEnd() const
    {
        return (get() == nullptr);
    }

    virtual void set(const Object* object) = 0;

    Object* operator*() const
    {
        return get();
    }

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

    void operator++(int)
    {
        forward();
    }

    FwdIt& operator+=(size_t dist)
    {
        forward(dist);
        return *this;
    }

#ifdef DEBUG

    bool isValid(const utl::Object* owner = nullptr) const;

    void
    invalidate() const
    {
        _owner = nullptr;
    }

    bool
    hasSameOwner(const FwdIt* it) const
    {
        return (_owner == it->_owner);
    }

    const Object*
    owner() const
    {
        return _owner;
    }

    void setOwner(const Object* owner, bool notifyOwner = true) const;
#endif
public:
    // for STL
    typedef Object* value_type;
    typedef Object*& reference;
    typedef Object** pointer;
    typedef std::forward_iterator_tag iterator_category;
    typedef std::ptrdiff_t difference_type;

private:
    enum flg_t
    {
        flg_const
    };

private:
#ifdef DEBUG
    void init();
    void deInit();
#else
    void
    init()
    {
    }
    void
    deInit()
    {
    }
#endif
#ifdef DEBUG
    mutable const Object* _owner;
    mutable bool _notifyOwner;
#endif
};


UTL_NS_END;


#include <libutl/TFwdIt.h>