monitorable.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:          April 2016
________________________________________________________________________

-*/

#include "notify.h"
#include "ptrman.h"
#include "refcount.h"


mExpClass(Basic) Monitorable : public CallBacker
{
public:

    class ChangeData;

    typedef int                                 ChangeType;
    typedef od_int64                            IDType;
    typedef od_int64                            DirtyCountType;
    typedef CNotifier<Monitorable,ChangeData>   ChangeDataNotifier;

                        Monitorable(const Monitorable&);
    virtual             ~Monitorable();
    Monitorable&        operator =(const Monitorable&);
    bool                operator ==(const Monitorable&) const;
    virtual Monitorable* clone() const  { return getClone(); }

    virtual ChangeDataNotifier&         objectChanged() const
        { return const_cast<Monitorable*>(this)->chgnotif_; }
    virtual Notifier<Monitorable>&      objectToBeDeleted() const
        { return const_cast<Monitorable*>(this)->delnotif_; }
    mDeclInstanceCreatedNotifierAccess( Monitorable );

    virtual void        touch() const           { dirtycount_++; }
    virtual DirtyCountType dirtyCount() const   { return dirtycount_; }
    virtual ChangeType  compareWith(const Monitorable&) const;

    static inline ChangeType cEntireObjectChange()
                        { return ChangeData::cEntireObjectChgType(); }
    static inline ChangeType cNoChange()
                        { return ChangeData::cNoChgType(); }
    static IDType       cUnspecChgID()
                        { return ChangeData::cUnspecChgID(); }
    static IDType       cEntireObjectChgID()
                        { return ChangeData::cUnspecChgID(); }

    mExpClass(Basic)    ChangeData : public std::pair<ChangeType,IDType>
    {
    public:

                        ChangeData( ChangeType typ, IDType id )
                            : std::pair<ChangeType,IDType>(typ,id)
                            , auxdata_(0)               {}
                        ChangeData(const ChangeData&);
        virtual         ~ChangeData()           {}
        ChangeData&     operator =(const ChangeData&);

        ChangeType      changeType() const      { return first; }
        IDType          ID() const              { return second; }
        bool            isEntireObject() const  { return first == -1; }
        bool            isNoChange() const      { return mIsUdf(first); }
        bool            hasUnspecID() const     { return second == -1; }
        bool            includes( ChangeType ct ) const
                        { return ct == first || isEntireObject(); }

        static inline ChangeType cEntireObjectChgType() { return -1; }
        static inline ChangeType cNoChgType()   { return 0; }
        static inline IDType cUnspecChgID()     { return -1; }
        static inline ChangeData AllChanged()   { return ChangeData(-1,-1); }
        static inline ChangeData NoChange()     { return ChangeData(0,-1); }

        mExpClass(Basic) AuxData : public RefCount::Referenced
        {
            protected:
                virtual ~AuxData()                      {}
        };

        RefMan<AuxData> auxdata_;
        template<class T> inline
        T*              auxDataAs()
                        { return static_cast<T*>( auxdata_.ptr() ); }
    };
    static ChangeType   changeNotificationTypeOf(CallBacker*);
    void                sendChangeNotification(const ChangeData&) const;
    void                sendEntireObjectChangeNotification() const;
    void                transferNotifsTo(const Monitorable&,
                                        const CallBacker* onlyfor=0) const;

    mExpClass(Basic)    AccessLocker : public Threads::Locker
    {
    public:
                        AccessLocker(const Monitorable&,bool forread=true);
        inline bool     convertToWrite()        { return convertToWriteLock(); }
    };

protected:

                        Monitorable();
    virtual Monitorable* getClone() const       = 0;

    mutable Threads::Lock accesslock_;

    void                copyAll(const Monitorable&);
    void                sendChgNotif(AccessLocker&,const ChangeData&) const;
    void                sendChgNotif(AccessLocker&,ChangeType,IDType) const;
    void                sendDelNotif() const;
    void                stopChangeNotifications() const
                        { chgnotifblocklevel_++; }
    void                resumeChangeNotifications() const;

    template <class T>
    inline T            getMemberSimple(const T&) const;
    template <class TMember,class TSetTo>
    inline void         setMemberSimple(TMember&,TSetTo,ChangeType,IDType);

    typedef Threads::Atomic<DirtyCountType>     DirtyCounter;

private:

    mutable DirtyCounter                dirtycount_;
    mutable Threads::Atomic<int>        chgnotifblocklevel_;

    mutable ChangeDataNotifier          chgnotif_;
    mutable Notifier<Monitorable>       delnotif_;
    mutable bool                        delalreadytriggered_;

    friend class                        MonitorLock;
    friend class                        ChangeNotifyBlocker;

    ChangeType          compareClassData(const Monitorable&) const;

};


#define mGetMonitoredChgData(cb,chgdata) \
    mCBCapsuleUnpack( Monitorable::ChangeData, chgdata, cb )

#define mGetMonitoredChgDataWithAux(cb,chgdata,T,auxvar) \
    mCBCapsuleUnpack( Monitorable::ChangeData, chgdata, cb ); \
    T* auxvar = chgdata.auxDataAs<T>()

#define mGetMonitoredChgDataWithCaller(cb,chgdata,caller) \
    mCBCapsuleUnpackWithCaller( Monitorable::ChangeData, chgdata, caller, cb )

#define mGetMonitoredChgDataWithAuxAndCaller(cb,chgdata,T,auxvar,caller) \
    mGetMonitoredChgDataWithCaller(cb,chgdata,caller); \
    T* auxvar = chgdata.auxDataAs<T>()

#define mGetMonitoredChgDataDoAll(cb,chgdata,doallact) \
    mGetMonitoredChgData(chgdata,cb); \
    if ( chgdata.changeType() == Monitored::cEntireObjectChange() ) \
        { doallact; }

#define mGetIDFromChgData( typ, var, chgdata ) \
    const typ var = typ::get( (typ::IDType)chgdata.ID() )


mExpClass(Basic) MonitorLock
{
public:
                        MonitorLock(const Monitorable&);
                        ~MonitorLock();

    void                unlockNow();
    void                reLock();

protected:

    Monitorable::AccessLocker locker_;
    bool                unlocked_;

};


mExpClass(Basic) ChangeNotifyBlocker
{
public:
                        ChangeNotifyBlocker(const Monitorable&,
                                            bool send_notif=true);
                        ~ChangeNotifyBlocker();

    void                unBlockNow();
    void                reBlock();

protected:

    const Monitorable&  obj_;
    bool                unblocked_;
    bool                sendnotif_;

};



template <class Mon> inline
Monitorable::ChangeType replaceMonitoredRef( ConstRefMan<Mon>& ref,
                                const Mon* newptr, CallBacker* only_for )
{
    const Mon* curptr = ref.ptr();
    if ( curptr == newptr )
        return false;

    Monitorable::ChangeType ct = Monitorable::cNoChange();
    if ( (newptr && !curptr) || (!newptr && curptr) )
        ct = Monitorable::cEntireObjectChange();
    else if ( curptr && newptr )
    {
        ct = curptr->compareWith( *newptr );
        curptr->transferNotifsTo( *newptr, only_for );
    }

    ref = newptr;
    return ct;
}

template <class Mon> inline
Monitorable::ChangeType replaceMonitoredRef( ConstRefMan<Mon>& ref,
                         const Mon& newref, CallBacker* only_for )
{
    return replaceMonitoredRef( ref, &newref, only_for );
}

template <class Mon> inline
Monitorable::ChangeType replaceMonitoredRef( ConstRefMan<Mon>& ref,
                        ConstRefMan<Mon>& newref, CallBacker* only_for )
{
    return replaceMonitoredRef( ref, newref.ptr(), only_for );
}

template <class Mon> inline
Monitorable::ChangeType replaceMonitoredRef( RefMan<Mon>& ref, Mon* newptr,
                                CallBacker* only_for )
{
    return replaceMonitoredRef( (ConstRefMan<Mon>&)ref, (const Mon*)newptr,
                                only_for );
}

template <class Mon> inline
Monitorable::ChangeType replaceMonitoredRef( RefMan<Mon>& ref, Mon& newref,
                                CallBacker* only_for )
{
    return replaceMonitoredRef( ref, &newref, only_for );
}

template <class Mon> inline
Monitorable::ChangeType replaceMonitoredRef( RefMan<Mon>& ref, RefMan<Mon>& newref,
                                CallBacker* only_for )
{
    return replaceMonitoredRef( ref, newref.ptr(), only_for );
}