monitoredobject.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) MonitoredObject : public CallBacker
{
public:
 
    class ChangeData;
 
 
    mUseType( Threads,                          Locker );
    typedef int                                 ChangeType;
    typedef od_int64                            IDType;
    typedef CNotifier<MonitoredObject,ChangeData>       ChangeDataNotifier;
 
                        MonitoredObject(const MonitoredObject&);
    virtual             ~MonitoredObject();
    MonitoredObject&    operator =(const MonitoredObject&);
    bool                operator ==(const MonitoredObject&) const;
    virtual MonitoredObject* clone() const      { return getClone(); }
 
    virtual ChangeDataNotifier&         objectChanged() const
                                        { return mSelf().chgnotif_; }
    virtual Notifier<MonitoredObject>&  objectToBeDeleted() const
                                        { return mSelf().delnotif_; }
    mDeclInstanceCreatedNotifierAccess( MonitoredObject );
 
    virtual void        touch() const           { dirtycount_++; }
    virtual DirtyCountType dirtyCount() const   { return dirtycount_; }
    virtual ChangeType  compareWith(const MonitoredObject&) 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:
 
        class AuxData;
 
                        ChangeData( ChangeType typ, IDType id, AuxData* data=0 )
                            : std::pair<ChangeType,IDType>(typ,id)
                            , auxdata_(data)            {}
                        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
        const T* auxDataAs() const
                        { return static_cast<const T*>( auxdata_.ptr() ); }
        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 MonitoredObject&,
                                        const CallBacker* onlyfor=0) const;
 
    mExpClass(Basic)    AccessLocker
    {
    public:
 
                        AccessLocker(const MonitoredObject&,bool forread=true);
                        AccessLocker(const AccessLocker&);
        AccessLocker&   operator =(const AccessLocker&);
                        ~AccessLocker();
 
        bool            isLocked() const;
        void            unlockNow();
        void            reLock(Locker::WaitType wt=Locker::WaitIfLocked);
        bool            convertToWrite();
 
        static void     enableLocking(bool yn);
 
        Locker*         theLock()       { return thelock_; }
 
    protected:
 
        Locker*         thelock_        = nullptr;
 
    };
 
protected:
 
                        MonitoredObject();
    virtual MonitoredObject* getClone() const   = 0;
 
    mutable Threads::Lock accesslock_;
 
    void                copyAll(const MonitoredObject&);
    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);
 
private:
 
    mutable DirtyCounter                dirtycount_;
    mutable Threads::Atomic<int>        chgnotifblocklevel_;
 
    mutable ChangeDataNotifier          chgnotif_;
    mutable Notifier<MonitoredObject>   delnotif_;
    mutable bool                        delalreadytriggered_;
 
    friend class                        MonitorLock;
    friend class                        ChangeNotifyBlocker;
 
    ChangeType          compareClassData(const MonitoredObject&) const;
 
};
 
 
#define mGetMonitoredChgData(cb,chgdata) \
    mCBCapsuleUnpack( MonitoredObject::ChangeData, chgdata, cb )
 
#define mGetMonitoredChgDataWithAux(cb,chgdata,T,auxvar) \
    mCBCapsuleUnpack( MonitoredObject::ChangeData, chgdata, cb ); \
    T* auxvar = chgdata.auxDataAs<T>()
 
#define mGetMonitoredChgDataWithCaller(cb,chgdata,caller) \
    mCBCapsuleUnpackWithCaller( MonitoredObject::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 MonitoredObject&);
                        ~MonitorLock();
 
    void                unlockNow();
    void                reLock();
 
protected:
 
    MonitoredObject::AccessLocker locker_;
    bool                unlocked_;
 
};
 
 
mExpClass(Basic) ChangeNotifyBlocker
{
public:
                        ChangeNotifyBlocker(const MonitoredObject&,
                                            bool send_notif=true);
                        ~ChangeNotifyBlocker();
 
    void                unBlockNow();
    void                reBlock();
 
protected:
 
    const MonitoredObject&      obj_;
    bool                unblocked_;
    bool                sendnotif_;
 
};
 
 
 
template <class Mon> inline
MonitoredObject::ChangeType replaceMonitoredRef( ConstRefMan<Mon>& ref,
                                const Mon* newptr, CallBacker* only_for )
{
    const Mon* curptr = ref.ptr();
    if ( curptr == newptr )
        return false;
 
    MonitoredObject::ChangeType ct = MonitoredObject::cNoChange();
    if ( (newptr && !curptr) || (!newptr && curptr) )
        ct = MonitoredObject::cEntireObjectChange();
    else if ( curptr && newptr )
    {
        ct = curptr->compareWith( *newptr );
        curptr->transferNotifsTo( *newptr, only_for );
    }
 
    ref = newptr;
    return ct;
}
 
template <class Mon> inline
MonitoredObject::ChangeType replaceMonitoredRef( ConstRefMan<Mon>& ref,
                         const Mon& newref, CallBacker* only_for )
{
    return replaceMonitoredRef( ref, &newref, only_for );
}
 
template <class Mon> inline
MonitoredObject::ChangeType replaceMonitoredRef( ConstRefMan<Mon>& ref,
                        ConstRefMan<Mon>& newref, CallBacker* only_for )
{
    return replaceMonitoredRef( ref, newref.ptr(), only_for );
}
 
template <class Mon> inline
MonitoredObject::ChangeType replaceMonitoredRef( RefMan<Mon>& ref, Mon* newptr,
                                CallBacker* only_for )
{
    return replaceMonitoredRef( (ConstRefMan<Mon>&)ref, (const Mon*)newptr,
                                only_for );
}
 
template <class Mon> inline
MonitoredObject::ChangeType replaceMonitoredRef( RefMan<Mon>& ref, Mon& newref,
                                CallBacker* only_for )
{
    return replaceMonitoredRef( ref, &newref, only_for );
}
 
template <class Mon> inline
MonitoredObject::ChangeType replaceMonitoredRef( RefMan<Mon>& ref, RefMan<Mon>& newref,
                                CallBacker* only_for )
{
    return replaceMonitoredRef( ref, newref.ptr(), only_for );
}