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 "monitoredobject.h"
 
 
// Tools for implementation of subclasses of MonitoredObject
 
 
 
#define mImplSimpleMonitoredGet_impl(fnnm,typ,memb,ovrspec) \
    typ fnnm() const ovrspec { return getMemberSimple( memb ); }
 
#define mImplSimpleMonitoredSet_impl(fnnm,typ,memb,chgtyp,ovrspec) \
    void fnnm( typ _set_to_ ) ovrspec \
        { setMemberSimple( memb, _set_to_, chgtyp, cUnspecChgID() ); }
 
#define mImplSimpleMonitoredGet( fnnm, typ, memb ) \
            mImplSimpleMonitoredGet_impl(fnnm,typ,memb,)
#define mImplSimpleMonitoredGetOverride( fnnm, typ, memb ) \
            mImplSimpleMonitoredGet_impl(fnnm,typ,memb,override)
 
#define mImplSimpleMonitoredSet(fnnm,typ,memb,chgtyp) \
            mImplSimpleMonitoredSet_impl(fnnm,typ,memb,chgtyp,)
#define mImplSimpleMonitoredSetOverride(fnnm,typ,memb,chgtyp) \
            mImplSimpleMonitoredSet_impl(fnnm,typ,memb,chgtyp,override)
 
#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) \
        MonitoredObject::AccessLocker accesslocker_( obj )
#define mLockMonitorable4Write(obj) \
        MonitoredObject::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,MonitoredObject::cEntireObjectChange(), \
                                 MonitoredObject::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); } \
        clss*           clone() const override  { return (clss*)getClone(); } \
        ChangeType      compareWith(const MonitoredObject&) const override
 
 
#define mDeclAbstractMonitorableAssignment(clss) \
    mDeclGenMonitorableAssignment(clss)
 
#define mDeclMonitorableAssignment(clss) \
    mDeclGenMonitorableAssignment(clss); \
    clss* getClone() const override             { return new clss( *this ); }
 
 
#define mImplEmptyMonitorableCopyClassData( clssnm ) \
void clssnm::copyClassData( const clssnm& oth ) \
{ \
}
 
#define mImplAlwaysDifferentMonitorableCompareClassData( clssnm ) \
MonitoredObject::ChangeType clssnm::compareClassData( const clssnm& oth ) const \
{ \
    return cEntireObjectChange(); \
}
 
#define mImplEmptyMonitorableCompare( clssnm ) \
MonitoredObject::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 MonitoredObject::ChangeType clss::compareWith( const MonitoredObject& 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 MonitoredObject::getMemberSimple( const T& memb ) const
{
    mLock4Read();
    return memb;
}
 
 
template <class TMember,class TSetTo>
inline void MonitoredObject::setMemberSimple( TMember& memb, TSetTo setto,
                                          ChangeType typ, IDType id )
{
    mLock4Read();
    if ( memb == setto )
        return; // common
 
    if ( mLock2Write() || !(memb == setto) )
    {
        memb = setto;
        mSendChgNotif( typ, id );
    }
}