callback.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 "refcount.h"
#include "sets.h"
#include "threadlock.h"
class NotifierAccess;
 
class CallBacker;
 
 
using CallBackFunction = void(CallBacker::*)(CallBacker*);
#define mCBFn(fn) (static_cast<CallBackFunction>(&fn))
 
#define mCB(obj,clss,fn) CallBack( static_cast<clss*>(obj), mCBFn(clss::fn))
 
using StaticCallBackFunction = void(*)(CallBacker*);
#define mSCB(fn) CallBack( (static_cast<StaticCallBackFunction>(&fn)) )
 
 
mExpClass(Basic) CallBack
{
public:
    static void         initClass();
                        CallBack()
                            : cberobj_(nullptr), fn_(nullptr), sfn_(nullptr)
                        {}
                        CallBack( CallBacker* o, CallBackFunction f )
                            : cberobj_(o), fn_(f), sfn_(nullptr)
                        {}
                        CallBack( StaticCallBackFunction f )
                            : cberobj_(nullptr), fn_(nullptr), sfn_(f)
                        {}
    bool                operator==(const CallBack&) const;
    bool                operator!=(const CallBack&) const;
 
    bool                willCall() const;
    void                doCall(CallBacker*) const;
    bool                isDisabled() const              { return disablecount_;}
    void                disable(bool yn=true) const;
    void                enable() const                  { disable(false); }
 
    inline CallBacker*                  cbObj()         { return cberobj_; }
    inline const CallBacker*            cbObj() const   { return cberobj_; }
    inline CallBackFunction             cbFn() const    { return fn_; }
    inline StaticCallBackFunction       scbFn() const   { return sfn_; }
 
    static bool addToMainThread(const CallBack&, CallBacker* =nullptr);
    static bool addToThread(Threads::ThreadID,const CallBack&,
                                    CallBacker* = nullptr);
    static bool callInMainThread(const CallBack&, CallBacker* =nullptr);
    static void removeFromThreadCalls(const CallBacker*);
                /* Removes callbacker from all event loops in all threads*/
 
 
    // See also mEnsureExecutedInMainThread macro
 
private:
 
    CallBacker*                         cberobj_;
    CallBackFunction                    fn_;
    StaticCallBackFunction              sfn_;
    mutable Threads::Atomic<int>        disablecount_;
    static Threads::ThreadID            mainthread_;
 
public:
 
    // Usually only called from mEnsureExecutedInMainThread:
 
    static bool                 queueIfNotInMainThread(CallBack,
                                                CallBacker* =nullptr);
    mDeprecated("Use removeFromThreadCalls")
                static void removeFromMainThread( const CallBacker* cber )
                { removeFromThreadCalls( cber ); }
};
 
#define mMainThreadCall( func ) \
CallBack::callInMainThread( CallBack( this, mCBFn(func) ), 0)
 
#define mEnsureExecutedInMainThread( func ) \
    if ( CallBack::queueIfNotInMainThread( \
        CallBack( this, mCBFn(func) ), 0 ) )  \
        return
 
#define mEnsureExecutedInMainThreadWithCapsule( func, caps ) \
    CallBack cb( this, mCBFn(func) ); \
    if ( CallBack::queueIfNotInMainThread(cb,caps->clone()) ) \
        return;
 
mExpClass(Basic) CallBackSet : public RefCount::Referenced
                             , public TypeSet<CallBack>
{
public:
                CallBackSet();
                CallBackSet(const CallBackSet&);
    CallBackSet& operator=(const CallBackSet&);
 
    void        doCall(CallBacker*);
    void        disableAll(bool yn=true);
    bool        hasAnyDisabled() const;
 
    void        removeWith(const CallBacker*);
    void        removeWith(CallBackFunction);
    void        removeWith(StaticCallBackFunction);
    void        transferTo(CallBackSet& to,const CallBacker* onlyfor=nullptr,
                                           const CallBacker* notfor=nullptr);
 
    mutable Threads::Lock   lock_;
 
protected:
 
                ~CallBackSet();
 
};
 
 
mExpClass(Basic) CallBacker
{
    friend class        NotifierAccess;
 
public:
                        CallBacker();
                        CallBacker(const CallBacker&);
    virtual             ~CallBacker();
 
    bool                attachCB(const NotifierAccess&,const CallBack&,
                                 bool onlyifnew=false) const;
    bool                attachCB(const NotifierAccess* notif,const CallBack& cb,
                                 bool onlyifnew=false) const;
    void                detachCB(const NotifierAccess&,const CallBack&) const;
    void                detachCB( const NotifierAccess* notif,
                                  const CallBack& cb ) const
                        { if ( notif ) detachCB( *notif, cb ); }
    bool                isNotifierAttached(const NotifierAccess*) const;
    virtual bool        isCapsule() const       { return false; }
 
    void                detachAllNotifiers() const;
private:
 
    bool                notifyShutdown(const NotifierAccess*,bool wait) const;
    ObjectSet<NotifierAccess>           attachednotifiers_;
    mutable Threads::Lock               attachednotifierslock_;
 
public:
 
    void                                stopReceivingNotifications() const
                                        { detachAllNotifiers(); }
 
    static void                         createReceiverForCurrentThread();
    static void                         removeReceiverForCurrentThread();
};
 
 
template <class T>
mClass(Basic) CBCapsule : public CallBacker
{
public:
                        CBCapsule( T d, CallBacker* c )
                            : data(d), caller(c)        {}
 
    T                   data;
    CallBacker*         caller;
 
    CBCapsule<T>*       clone() const
                        { return new CBCapsule<T>(data,caller); }
    virtual bool        isCapsule() const               { return true; }
 
};
 
 
#define mCBCapsuleGet(PayLoadType,var,cb) \
CBCapsule<PayLoadType>* var = dynamic_cast< CBCapsule<PayLoadType>* >( cb );
 
#define mCBCapsuleUnpack(PayLoadType,var,cb) \
mCBCapsuleGet(PayLoadType,cb##caps,cb) \
PayLoadType var = cb##caps->data
 
#define mCBCapsuleUnpackWithCaller(PayLoadType,var,cber,cb) \
mCBCapsuleGet(PayLoadType,cb##caps,cb) \
PayLoadType var = cb##caps->data; \
CallBacker* cber = cb##caps->caller
 
#include "notify.h"