callback.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 / End 2015 / April 2016
 Contents:      Notification and Callbacks
________________________________________________________________________

-*/

#include "basicmod.h"
#include "refcount.h"
#include "sets.h"
#include "threadlock.h"
class NotifierAccess;

class CallBacker;


typedef void (CallBacker::*CallBackFunction)(CallBacker*);
#define mCBFn(fn) (static_cast<CallBackFunction>(&fn))

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

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

class QCallBackEventReceiver;


mExpClass(Basic) CallBack
{
public:
    static void         initClass();
                        CallBack()
                            : cberobj_(0), fn_(0), sfn_(0)      {}
                        CallBack( CallBacker* o, CallBackFunction f )
                            : cberobj_(o), fn_(f), sfn_(0)      {}
                        CallBack( StaticCallBackFunction f )
                            : cberobj_(0), fn_(0), sfn_(f)      {}
    bool                operator==(const CallBack&) const;
    inline bool         operator!=( const CallBack& cb ) const
                        { return !(*this==cb); }

    inline bool         willCall() const
                        { return disablecount_ == 0
                              && ((cberobj_ && fn_) || sfn_); }
    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* =0);
    static bool addToThread(Threads::ThreadID,const CallBack&,
                                    CallBacker* = 0);
    static bool callInMainThread(const CallBack&, CallBacker* =0);
    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* =0);
    static mDeprecated 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=0);

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

protected:

    void                detachAllNotifiers() const;
private:

    bool                notifyShutdown(const NotifierAccess*,bool wait) const;
    ObjectSet<QCallBackEventReceiver>   receivers_;
    Threads::Lock                       receiverslock_;

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

public:

    void                                stopReceivingNotifications() const
                                        { detachAllNotifiers(); }

    static void                         createReceiverForCurrentThread();
    static void                         removeReceiverForCurrentThread();
};


template <class PLT>
mClass(Basic) CBCapsule : public CallBacker
{
public:

    typedef PLT         PayLoadType;

                        CBCapsule( PLT d, CallBacker* c )
                            : data(d), caller(c)        {}

    PLT                 data;
    CallBacker*         caller;

    CBCapsule<PLT>*     clone() const
                            { return new CBCapsule<PLT>(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