monitor.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 "monitorable.h"


// Tools for implementation of subclasses of Monitorable


#define mImplSimpleMonitoredGet(fnnm,typ,memb) \
    typ fnnm() const { return getMemberSimple( memb ); }

#define mImplSimpleMonitoredSet(fnnm,typ,memb,chgtyp) \
    void fnnm( typ _set_to_ ) { setMemberSimple( memb, _set_to_, chgtyp, \
                                    cUnspecChgID() ); }

#define mImplSimpleMonitoredGetSet(pfx,fnnmget,fnnmset,typ,memb,chgtyp) \
    pfx mImplSimpleMonitoredGet(fnnmget,typ,memb) \
    pfx mImplSimpleMonitoredSet(fnnmset,const typ&,memb,chgtyp)


// Generalised; also available for friend classes
#define mLockMonitorable4Read(obj) \
        Monitorable::AccessLocker accesslocker_( obj )
#define mLockMonitorable4Write(obj) \
        Monitorable::AccessLocker accesslocker_( obj, false )
#define mMonitorableLock2Write(obj) accesslocker_.convertToWrite()
#define mMonitorableReLock(obj) accesslocker_.reLock()
#define mMonitorableUnlockAllAccess(obj) accesslocker_.unlockNow()
#define mMonitorableAccessLocker(obj) accesslocker_
#define mSendMonitorableChgNotif(obj,typ,id) \
        (obj).sendChgNotif(accesslocker_,typ,id)
#define mSendMonitorableEntireObjChgNotif(obj) \
        mSendMonitorableChgNotif(obj,Monitorable::cEntireObjectChange(), \
                                 Monitorable::cEntireObjectChgID())

// Shorthands for class implementation
#define mLock4Read() mLockMonitorable4Read(*this)
#define mLock4Write() mLockMonitorable4Write(*this)
#define mLock2Write() mMonitorableLock2Write(*this)
#define mReLock() mMonitorableReLock(*this)
#define mUnlockAllAccess() mMonitorableUnlockAllAccess(*this)
#define mAccessLocker() mMonitorableAccessLocker(*this)
#define mSendChgNotif(typ,id) mSendMonitorableChgNotif(*this,typ,id)
#define mSendEntireObjChgNotif() mSendMonitorableEntireObjChgNotif(*this)



#define mDeclGenMonitorableAssignment(clss) \
    private: \
        void            copyClassData(const clss&); \
        ChangeType      compareClassData(const clss&) const; \
    protected: \
        void            copyAll(const clss&); \
    public: \
                        clss(const clss&); \
        clss&           operator =(const clss&); \
        bool            operator ==(const clss&) const; \
        inline bool     operator !=( const clss& oth ) const \
                        { return !(*this == oth); } \
        virtual clss*   clone() const           { return (clss*)getClone(); } \
        ChangeType      compareWith(const Monitorable&) const


#define mDeclAbstractMonitorableAssignment(clss) \
    mDeclGenMonitorableAssignment(clss)

#define mDeclMonitorableAssignment(clss) \
    mDeclGenMonitorableAssignment(clss); \
    virtual clss* getClone() const              { return new clss( *this ); }


#define mImplEmptyMonitorableCopyClassData( clssnm ) \
void clssnm::copyClassData( const clssnm& oth ) \
{ \
}

#define mImplAlwaysDifferentMonitorableCompareClassData( clssnm ) \
Monitorable::ChangeType clssnm::compareClassData( const clssnm& oth ) const \
{ \
    return cEntireObjectChange(); \
}

#define mImplEmptyMonitorableCompare( clssnm ) \
Monitorable::ChangeType clssnm::compareClassData( const clssnm& oth ) const \
{ \
    return cNoChange(); \
}


#define mGenImplMonitorableAssignment(pfx,clss,baseclss) \
pfx clss& clss::operator =( const clss& oth ) \
{ \
    const ChangeType chgtyp = compareWith( oth ); \
    if ( chgtyp != cNoChange() ) \
    { \
        mLock4Write(); \
        AccessLocker lckr( oth ); \
        copyAll( oth ); \
        mSendChgNotif( chgtyp, cUnspecChgID() ); \
    } \
    return *this; \
} \
\
pfx bool clss::operator ==( const clss& oth ) const \
\
{ \
    return compareWith( oth ) == cNoChange(); \
} \
\
pfx void clss::copyAll( const clss& oth ) \
{ \
    baseclss::copyAll( oth ); \
    AccessLocker lckr( oth ); \
    copyClassData( oth ); \
} \
\
pfx Monitorable::ChangeType clss::compareWith( const Monitorable& mon ) const \
{ \
    if ( this == &mon ) \
        return cNoChange(); \
    mDynamicCastGet( const clss*, oth, &mon ); \
    if ( !oth ) \
        return cEntireObjectChange(); \
\
    mLock4Read(); \
    AccessLocker lckr( *oth ); \
    const ChangeType ct = compareClassData( *oth ); \
    mUnlockAllAccess(); \
\
    return ct != cNoChange() ? ct : baseclss::compareWith( *oth ); \
}


#define mImplMonitorableAssignment(clss,baseclss) \
    mGenImplMonitorableAssignment(,clss,baseclss)


#define mImplMonitorableAssignmentWithNoMembers( clss, baseclss ) \
    mImplMonitorableAssignment(clss,baseclss) \
    mImplEmptyMonitorableCopyClassData( clss ) \
    mImplEmptyMonitorableCompare( clss )



#define mStartMonitorableCompare() ChangeType chgtype = cNoChange()

#define mHandleMonitorableCompare( memb, val ) \
    if ( !(memb == oth.memb) ) \
    { \
        if ( chgtype == cNoChange() || chgtype == val ) \
            chgtype = val; \
        else \
            return cEntireObjectChange(); \
    }

#define mHandleMonitorableComparePtrContents( memb, val ) \
    if ( (memb && !oth.memb) || (!memb && oth.memb) || !(*memb == *oth.memb) ) \
    { \
        if ( chgtype == cNoChange() || chgtype == val ) \
            chgtype = val; \
        else \
            return cEntireObjectChange(); \
    }

#define mDeliverMonitorableCompare() return chgtype;


#define mDeliverSingCondMonitorableCompare(nochgcond,chgtype) \
    return (nochgcond) ? cNoChange() : chgtype


#define mDeliverYesNoMonitorableCompare(nochgcond) \
    mDeliverSingCondMonitorableCompare( nochgcond, cEntireObjectChange() )


template <class T>
inline T Monitorable::getMemberSimple( const T& memb ) const
{
    mLock4Read();
    return memb;
}


template <class TMember,class TSetTo>
inline void Monitorable::setMemberSimple( TMember& memb, TSetTo setto,
                                          ChangeType typ, IDType id )
{
    mLock4Read();
    if ( memb == setto )
        return; // common

    if ( mLock2Write() || !(memb == setto) )
    {
        memb = setto;
        mSendChgNotif( typ, id );
    }
}