callback.h

Go to the documentation of this file.

#ifndef callback_h
#define callback_h

/*+
________________________________________________________________________

 (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 "refcount.h"
#include "sets.h"
#include "threadlock.h"

class CallBacker;


typedef void (CallBacker::*CallBackFunction)(CallBacker*);
#define mCBFn(clss,fn) ((CallBackFunction)(&clss::fn))

#define mCB(obj,clss,fn) CallBack( static_cast<clss*>(obj), mCBFn(clss,fn))

typedef void (*StaticCallBackFunction)(CallBacker*);
#define mSCB(fn) CallBack( ((StaticCallBackFunction)(&fn)) )


mExpClass(Basic) CallBack
{
public:
    static void         initClass();

                        CallBack( CallBacker* o=0, CallBackFunction f=0 )
                            : obj_( o ), fn_( f ), sfn_( 0 )    {}
                        CallBack( StaticCallBackFunction f )
                            : obj_( 0 ), fn_( 0 ), sfn_( f )    {}
    inline int          operator==( const CallBack& c ) const
                        { return obj_==c.obj_ && fn_==c.fn_ && sfn_==c.sfn_; }
    inline int          operator!=( const CallBack& cb ) const
                        { return !(*this==cb); }

    inline bool         willCall() const
                        { return (obj_ && fn_) || sfn_; }
    void                doCall(CallBacker*) const;

    inline CallBacker*                  cbObj()                 { return obj_; }
    inline const CallBacker*            cbObj() const           { return obj_; }
    inline CallBackFunction             cbFn() const            { return fn_; }
    inline StaticCallBackFunction       scbFn() const           { return sfn_; }

    static bool         addToMainThread(const CallBack&, CallBacker* =0);
    static bool         callInMainThread(const CallBack&, CallBacker* =0);
    static void         removeFromMainThread(const CallBacker*);


    // See also mEnsureExecutedInMainThread macro

protected:

    CallBacker*                         obj_;
    CallBackFunction                    fn_;
    StaticCallBackFunction              sfn_;

public:

    // Usually only called from mEnsureExecutedInMainThread:

    static bool                         queueIfNotInMainThread(CallBack,
                                                        CallBacker* =0);
};

#define mMainThreadCall( func ) \
CallBack::callInMainThread( CallBack( this, ((CallBackFunction)(&func) ) ), 0)

#define mEnsureExecutedInMainThread( func ) \
    if ( CallBack::queueIfNotInMainThread( \
        CallBack( this, ((CallBackFunction)(&func) ) ), 0 ) )  \
        return


mExpClass(Basic) CallBackSet : public TypeSet<CallBack>
{ mRefCountImpl(CallBackSet)
public:
                CallBackSet();
                CallBackSet(const CallBackSet&);
    CallBackSet& operator=(const CallBackSet&);

    void        doCall(CallBacker*,CallBacker* exclude=0);
    void        removeWith(CallBacker*);
    void        removeWith(CallBackFunction);
    void        removeWith(StaticCallBackFunction);

    inline bool isEnabled() const { return enabled_; }
    bool        doEnable( bool yn=true );

    mutable Threads::Lock       lock_;
private:
    bool                        enabled_;
};


mExpClass(Basic) NotifierAccess
{

    friend class        NotifyStopper;
    friend class        CallBacker;

public:

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

    void                notify(const CallBack&,bool first=false);
    bool                notifyIfNotNotified(const CallBack&);
    void                remove(const CallBack&);
    bool                removeWith(CallBacker*,bool wait=true);

    inline bool isEnabled() const       { return cbs_.isEnabled(); }
    inline bool enable( bool yn=true )  { return cbs_.doEnable(yn); }
    inline bool disable()               { return cbs_.doEnable(false); }

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

    bool                isShutdownSubscribed(CallBacker*) const;
protected:
    static void         doTrigger(CallBackSet&,CallBacker* c,
                                  CallBacker* exclude);
    void                addShutdownSubscription(CallBacker*);
    bool                removeShutdownSubscription(CallBacker*, bool wait);

    ObjectSet<CallBacker>       shutdownsubscribers_;
    mutable Threads::Lock       shutdownsubscriberlock_;
};


template <class T>
mClass(Basic) Notifier : public NotifierAccess
{
public:

    void                trigger( T& t ) { trigger(&t); }

                        // Following functions are usually used by T class only:
                        Notifier( T* c )                        { cber_ = c; }

    inline void         trigger( CallBacker* c=0, CallBacker* exclude=0 )
                        { doTrigger( cbs_, c ? c : cber_, exclude ); }
};


mExpClass(Basic) CallBacker
{
    friend class        NotifierAccess;
public:
                        CallBacker();
                        CallBacker(const CallBacker&);
    virtual             ~CallBacker();

    bool                attachCB(NotifierAccess&,const CallBack&,
                                 bool onlyifnew=false);
    bool                attachCB(NotifierAccess* notif,const CallBack& cb,
                                 bool onlyifnew=false)
                        { return notif ? attachCB(*notif,cb,onlyifnew):false; }
    void                detachCB(NotifierAccess&,const CallBack&);
    void                detachCB(NotifierAccess* notif,const CallBack& cb)
                        { if ( notif ) detachCB( *notif, cb ); }
    bool                isNotifierAttached(NotifierAccess*) const;

protected:
    void                detachAllNotifiers();
private:

    bool                notifyShutdown(NotifierAccess*,bool wait);

    ObjectSet<NotifierAccess>   attachednotifiers_;
    mutable Threads::Lock       attachednotifierslock_;
};


#define mAttachCB( notifier, func ) \
attachCB( notifier, CallBack( this, ((CallBackFunction)(&func) ) ), false )

#define mAttachCBIfNotAttached( notifier, func ) \
attachCB( notifier, CallBack( this, ((CallBackFunction)(&func) ) ), true )

#define mDetachCB( notifier, func ) \
detachCB( notifier, CallBack( this, ((CallBackFunction)(&func) ) ) )

template <class T>
mClass(Basic) CBCapsule : public CallBacker
{
public:
    CBCapsule( T d, CallBacker* c )
    : data(d), caller(c)        {}

    T                   data;
    CallBacker*         caller;
};


#define mCBCapsuleGet(T,var,cb) \
CBCapsule<T>* var = dynamic_cast< CBCapsule<T>* >( cb );

#define mCBCapsuleUnpack(T,var,cb) \
mCBCapsuleGet(T,cb##caps,cb) \
T var = cb##caps->data

#define mCBCapsuleUnpackWithCaller(T,var,cber,cb) \
mCBCapsuleGet(T,cb##caps,cb) \
T var = cb##caps->data; \
CallBacker* cber = cb##caps->caller


template <class T,class C>
mClass(Basic) CNotifier : public NotifierAccess
{
public:

    void                trigger( C c, T& t )            { trigger(c,&t); }

// Following functions are usually used by T class only:

                        CNotifier( T* cb )      { cber_ = cb; }

    inline void         trigger( C c, CallBacker* cb=0 )
                        {
                            CBCapsule<C> caps( c, cb ? cb : cber_ );
                            doTrigger( cbs_, &caps, 0 );
                        }
};


mExpClass(Basic) NotifyStopper
{
public:
                NotifyStopper( NotifierAccess& na );
                ~NotifyStopper();

    void        enable();    
    void        disable();    
    void        restore();

protected:

    NotifierAccess&     thenotif_;
    bool                oldst_;

};


// Set of macros to add an instanceCreated() notifier
// This can provide a notification of any instance of a class being produced

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


#endif