notify.h

Go to the documentation of this file.

#pragma once
 
/*+
________________________________________________________________________
 
 (C) dGB Beheer B.V.; (LICENSE) http://opendtect.org/OpendTect_license.txt
 Author:        A.H.Bril
 Date:          8-11-1995
 Contents:      Notification and Callbacks
 RCS:           $Id$
________________________________________________________________________
 
-*/
 
#include "basicmod.h"
#include "callback.h"
 
 
mExpClass(Basic) NotifierAccess
{
 
    friend class        NotifyStopper;
    friend class        CallBacker;
 
public:
 
                        NotifierAccess(const NotifierAccess&);
                        NotifierAccess();
    virtual             ~NotifierAccess();
 
    inline bool         isEmpty() const       { return cbs_.isEmpty(); }
    inline void         setEmpty()            { cbs_.setEmpty(); }
    inline bool         isEnabled() const     { return !cbs_.hasAnyDisabled(); }
    inline void         enable( bool yn=true ){ cbs_.disableAll(!yn); }
    inline void         disable()             { cbs_.disableAll(true); }
 
    bool                willCall(const CallBacker*) const;
    void                notify(const CallBack&,bool first=false) const;
    bool                notifyIfNotNotified(const CallBack&) const;
    void                remove(const CallBack&) const;
    bool                removeWith(const CallBacker*,bool wait=true) const;
 
    void                transferCBSTo(const NotifierAccess&,
                                      const CallBacker* only_for,
                                      const CallBacker* not_for=0) const;
 
    CallBackSet&        cbs_;
    CallBacker*         cber_;
 
protected:
 
    static void         doTrigger(CallBackSet&,const CallBacker*);
    void                addShutdownSubscription(const CallBacker*) const;
    bool                removeShutdownSubscription(const CallBacker*,
                                                    bool wait) const;
 
    mutable ObjectSet<const CallBacker> shutdownsubscribers_;
    mutable Threads::Lock       shutdownsubscriberlock_;
 
public:
 
    bool                isShutdownSubscribed(const CallBacker*) const;
 
};
 
 
template <class T>
mClass(Basic) Notifier : public NotifierAccess
{
public:
 
                        // Following functions are usually used by T class only:
                        Notifier( T* c )                        { cber_ = c; }
 
    inline void         trigger()
                        { if ( !cbs_.isEmpty() ) doTrigger( cbs_, cber_ ); }
    inline void         trigger( T& t )
                        { if ( !cbs_.isEmpty() ) doTrigger( cbs_, &t ); }
    inline void         trigger( CallBacker* c )
                        { if ( !cbs_.isEmpty() ) doTrigger( cbs_, c ); }
 
};
 
 
#define mAttachObjCB( objptr, notifier, func, chk ) \
    attachCB( notifier, CallBack( objptr, mCBFn(func) ), chk )
#define mDetachObjCB( objptr, notifier, func ) \
    detachCB( notifier, CallBack( objptr, mCBFn(func) ) )
 
#define mAttachCB( notifier, func ) \
    mAttachObjCB( this, notifier, func, false )
 
#define mAttachCBIfNotAttached( notifier, func ) \
    mAttachObjCB( this, notifier, func, true )
 
#define mDetachCB( notifier, func ) \
    mDetachObjCB( this, notifier, func )
 
 
template <class T,class PayLoad>
mClass(Basic) CNotifier : public NotifierAccess
{
public:
                        CNotifier( T* cb )      { cber_ = cb; }
 
    inline void         trigger( PayLoad pl )
                        {
                            CBCapsule<PayLoad> caps( pl, cber_ );
                            doTrigger( cbs_, &caps );
                        }
 
    inline void         trigger( PayLoad pl, CallBacker* cb )
                        {
                            if ( !cb )
                                trigger( pl );
                            else
                            {
                                CBCapsule<PayLoad> caps( pl, cb );
                                doTrigger( cbs_, &caps );
                            }
                        }
    inline void         trigger( PayLoad pl, T& t )
                        { trigger(pl,&t); }
 
};
 
 
mExpClass(Basic) NotifyStopper
{
public:
                NotifyStopper(NotifierAccess&,const CallBacker* only_for=0);
                ~NotifyStopper();
 
    void        enableNotification();
    void        disableNotification();
 
protected:
 
    NotifierAccess&     thenotif_;
    bool                isdisabled_;
    const CallBacker*   onlyfor_;
 
    void                setDisabled(bool);
 
public:
 
    mDeprecated("use enableNotification") void restore()
                        { enableNotification(); }
    mDeprecated("use enableNotification") void enable()
                        { enableNotification(); }
    mDeprecated("use disableNotification") void disable()
                        { disableNotification(); }
 
};
 
 
 
#define mDeclInstanceCreatedNotifierAccess(clss) \
    static Notifier<clss>&      instanceCreated()
 
#define mDefineInstanceCreatedNotifierAccess(clss) \
Notifier<clss>& clss::instanceCreated() \
{ \
    mDefineStaticLocalObject( Notifier<clss>, theNotif, (0)); \
    return theNotif; \
}
 
#define mTriggerInstanceCreatedNotifier() \
    instanceCreated().trigger( this )