notify.h

Go to the documentation of this file.

#pragma once

/*+
________________________________________________________________________

 (C) dGB Beheer B.V.; (LICENSE) http://opendtect.org/OpendTect_license.txt
 Author:        Bert / Kris
 Date:          Nov 1995 / April 2016
 Contents:      Notifications
________________________________________________________________________

-*/

#include "basicmod.h"
#include "callback.h"


mExpClass(Basic) NotifierAccess
{

    friend class        NotifyStopper;
    friend class        CallBacker;

public:

                        NotifierAccess(const NotifierAccess&);
                        NotifierAccess();
    virtual             ~NotifierAccess();

    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;

    inline bool isEnabled() const       { return !cbs_.hasAnyDisabled(); }
    inline void enable( bool yn=true )  { return cbs_.disableAll(!yn); }
    inline void disable()               { return cbs_.disableAll(true); }

    inline bool isEmpty() const { return cbs_.isEmpty(); }
    bool                willCall(const CallBacker*) const;
    CallBackSet&        cbs_;
    CallBacker*         cber_;

    bool                isShutdownSubscribed(const CallBacker*) const;

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_;

};


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);

};



#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 )