monitoriter.h

Go to the documentation of this file.

#pragma once

/*+
________________________________________________________________________

 (C) dGB Beheer B.V.; (LICENSE) http://opendtect.org/OpendTect_license.txt
 Author:        Bert
 Date:          May 2001 / Mar 2016
 Contents:      PickSet base classes
________________________________________________________________________

-*/

#include "monitorable.h"


template <class ITyp>
mClass(Basic) MonitorableIterBase
{
public:

    typedef ITyp        IdxType;
    typedef IdxType     size_type;
    enum Direction      { Forward, Backward };

    inline              MonitorableIterBase(const Monitorable&,IdxType startidx,
                                                           IdxType stopidx);
    inline              MonitorableIterBase(const MonitorableIterBase&);
    inline virtual      ~MonitorableIterBase()  { retire(); }
    inline const Monitorable& monitored() const { return obj_; }

    inline bool         isEmpty() const         { return size() < 1; }
    inline size_type    size() const;

    inline bool         next();
    inline bool         isForward() const       { return dir_ == Forward; }

    inline bool         isValid() const         { return isPresent(curidx_); }
    inline bool         atFirst() const         { return curidx_ == startidx_; }
    inline bool         atLast() const          { return curidx_ == stopidx_; }
    inline IdxType      curIdx() const          { return curidx_; }
    inline bool         isPresent(IdxType) const;

    virtual void        retire()                {}
    virtual void        reInit();

protected:

    const Monitorable&  obj_;
    const Direction     dir_;
    const IdxType       startidx_;
    const IdxType       stopidx_;

    IdxType             curidx_;

    mDefNoAssignmentOper(MonitorableIterBase)

};



template <class ITyp>
mClass(Basic) MonitorableIter4Read : public MonitorableIterBase<ITyp>
{
public:

    inline              MonitorableIter4Read(const Monitorable&,
                                             ITyp startidx,ITyp stopidx);
    inline              MonitorableIter4Read(const MonitorableIter4Read&);

    virtual void        reInit();
    virtual void        retire();

protected:

    MonitorLock         ml_;

    mDefNoAssignmentOper(MonitorableIter4Read)

};


template <class ITyp>
mClass(Basic) MonitorableIter4Write : public MonitorableIterBase<ITyp>
{
public:

    inline              MonitorableIter4Write(Monitorable&,
                                              ITyp startidx,ITyp stopidx);
    inline              MonitorableIter4Write(const MonitorableIter4Write&);

    inline Monitorable& edited()
                        { return const_cast<Monitorable&>(this->monitored()); }
                        // compiler bug? does not work without the 'this'
                        // more of that in the implementations below ...

protected:

    inline void         insertedAtCurrent();
    inline void         currentRemoved();

    mDefNoAssignmentOper(MonitorableIter4Write)

};


template <class ITyp> inline
MonitorableIterBase<ITyp>::MonitorableIterBase( const Monitorable& obj,
                                        ITyp startidx, ITyp stopidx )
    : obj_(obj)
    , startidx_(startidx)
    , stopidx_(stopidx)
    , dir_(startidx<=stopidx ? Forward : Backward)
{
    if ( startidx_ < 0 || stopidx_ < 0 )
    {
        // empty. make this a standard situation:
        const_cast<IdxType&>( startidx_ ) = 0;
        const_cast<IdxType&>( stopidx_ ) = -1;
        const_cast<Direction&>( dir_ ) = Forward;
    }
    reInit();
}


template <class ITyp> inline
MonitorableIterBase<ITyp>::MonitorableIterBase( const MonitorableIterBase& oth )
    : obj_(oth.monitored())
    , startidx_(oth.startidx_)
    , stopidx_(oth.stopidx_)
    , dir_(oth.dir_)
    , curidx_(oth.curidx_)
{
}


template <class ITyp> inline
bool MonitorableIterBase<ITyp>::next()
{
    if ( dir_ == Forward )
        { curidx_++; return curidx_ <= stopidx_; }
    else
        { curidx_--; return curidx_ >= stopidx_; }
}


template <class ITyp> inline
bool MonitorableIterBase<ITyp>::isPresent( IdxType idx ) const
{
    if ( dir_ == Forward )
        return idx >= startidx_ && idx <= stopidx_;
    else
        return idx <= startidx_ && idx >= stopidx_;
}


template <class ITyp> inline typename
MonitorableIterBase<ITyp>::size_type MonitorableIterBase<ITyp>::size() const
{
    return dir_ == Forward ? stopidx_-startidx_+1 : startidx_-stopidx_+1;
}


template <class ITyp> inline
void MonitorableIterBase<ITyp>::reInit()
{
    curidx_ = dir_ == Forward ? startidx_ - 1 : startidx_ + 1;
}


template <class ITyp> inline
MonitorableIter4Read<ITyp>::MonitorableIter4Read( const Monitorable& obj,
                                                  ITyp startidx, ITyp stopidx )
    : MonitorableIterBase<ITyp>(obj,startidx,stopidx)
    , ml_(obj)
{
}


template <class ITyp> inline
MonitorableIter4Read<ITyp>::MonitorableIter4Read(
                                const MonitorableIter4Read& oth )
    : MonitorableIterBase<ITyp>(oth)
    , ml_(oth.obj_)
{
}


template <class ITyp> inline
void MonitorableIter4Read<ITyp>::retire()
{
    ml_.unlockNow();
}


template <class ITyp> inline
void MonitorableIter4Read<ITyp>::reInit()
{
    ml_.reLock();
    MonitorableIterBase<ITyp>::reInit();
}


template <class ITyp> inline
MonitorableIter4Write<ITyp>::MonitorableIter4Write( Monitorable& obj,
                                                  ITyp startidx, ITyp stopidx )
    : MonitorableIterBase<ITyp>(obj,startidx,stopidx)
{
}


template <class ITyp> inline
MonitorableIter4Write<ITyp>::MonitorableIter4Write(
                                const MonitorableIter4Write& oth )
    : MonitorableIterBase<ITyp>(oth)
{
}


template <class ITyp> inline
void MonitorableIter4Write<ITyp>::insertedAtCurrent()
{
    if ( this->dir_ == MonitorableIterBase<ITyp>::Backward )
        const_cast<ITyp&>(this->startidx_)++;
    else
    {
        const_cast<ITyp&>(this->stopidx_)++;
        this->curidx_++;
    }
}


template <class ITyp> inline
void MonitorableIter4Write<ITyp>::currentRemoved()
{
    if ( this->dir_ == MonitorableIterBase<ITyp>::Backward )
        const_cast<ITyp&>(this->startidx_)--;
    else
    {
        const_cast<ITyp&>(this->stopidx_)--;
        this->curidx_--;
    }
}