callback.h

#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: callback.h,v 1.43 2009-07-22 16:01:13 cvsbert Exp $
________________________________________________________________________

-*/

#include "sets.h"
#include <string>

struct CallBacker { virtual ~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))

mClass CallBack
{
public:
                        CallBack( CallBacker* o=0, CallBackFunction f=0 )
                        { obj_ = o; fn_ = f; }
    inline int          operator==( const CallBack& cb ) const
                        { return obj_ == cb.obj_ && fn_ == cb.fn_; }
    inline int          operator!=( const CallBack& cb ) const
                        { return obj_ != cb.obj_ || fn_ != cb.fn_; }

    inline bool         willCall() const
                        { return obj_ && fn_; }
    inline void         doCall( CallBacker* o )
                        { if ( obj_ && fn_ ) (obj_->*fn_)( o ); }

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

protected:

    CallBacker*         obj_;
    CallBackFunction    fn_;

};


mClass CallBackSet : public TypeSet<CallBack>
{
public:

    void        doCall(CallBacker*,const bool* enabledflag=0,
                        CallBacker* exclude=0);
    void        removeWith(CallBacker*);
};

inline void CallBackSet::doCall( CallBacker* obj,
                                 const bool* enabledflag,
                                 CallBacker* exclude )
{
    const bool enabled_ = true;
    const bool& enabled = enabledflag ? *enabledflag : enabled_;
    if ( !enabled ) return;

    TypeSet<CallBack> cbscopy = *this;
    for ( int idx=0; idx<cbscopy.size(); idx++ )
    {
        CallBack& cb = cbscopy[idx];
        if ( indexOf(cb)==-1 )
            continue;

        if ( cb.cbObj() != exclude )
            cb.doCall( obj );
    }
}


inline void CallBackSet::removeWith( CallBacker* cbrm )
{
    for ( int idx=0; idx<size(); idx++ )
    {
        CallBack& cb = (*this)[idx];
        if ( cb.cbObj() == cbrm )
            { remove( idx ); idx--; }
    }
}


template <class T>
class 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


mClass NotifierAccess
{

    friend class        NotifyStopper;

public:

                        NotifierAccess()
                            : enabled_(true)                    {}
    virtual             ~NotifierAccess()                       {}

    virtual void        notify(const CallBack&)                 =0;
    virtual void        notifyIfNotNotified(const CallBack&)    =0;
    virtual void        remove(const CallBack&)                 =0;

    bool                enable( bool newstatus=true )
                        { return doEnable(newstatus); }
    bool                disable()               { return doEnable(false); }
    bool                isEnabled() const       { return enabled_; }

protected:

    bool                enabled_;
    inline bool         doEnable( bool newstatus=true )
                        { bool res=enabled_; enabled_=newstatus; return res; }
};


mClass NamedNotifierSet
{
public:
                                ~NamedNotifierSet()
                                { deepErase( names_ ); }

    void                        add(const char* nm,NotifierAccess&);
    NotifierAccess*             find(const char*) const;

protected:

    ObjectSet<NotifierAccess>   notifs_;
    ObjectSet<std::string>      names_;

};


inline void NamedNotifierSet::add( const char* nm, NotifierAccess& na )
{
    names_ += new std::string( nm );
    notifs_ += &na;
}


inline NotifierAccess* NamedNotifierSet::find( const char* nm ) const
{
    for ( int idx=0; idx<names_.size(); idx++ )
        if ( *names_[idx] == nm )
            return const_cast<NotifierAccess*>( notifs_[idx] );
    return 0;
}


mClass i_Notifier : public NotifierAccess
{
public:

    virtual void        notify( const CallBack& cb )    { cbs_ += cb; }
    virtual void        notifyIfNotNotified( const CallBack& cb )
                        { if ( cbs_.indexOf(cb)==-1 ) notify(cb); }
    virtual void        remove( const CallBack& cb )    { cbs_ -= cb; }
    virtual void        removeWith(CallBacker*);

    CallBackSet         cbs_;
    CallBacker*         cber_;

                        i_Notifier()    {}
};


inline void i_Notifier::removeWith( CallBacker* cb )
{
    if ( cber_ == cb )
        { cbs_.erase(); cber_ = 0; return; }

    cbs_.removeWith( cb );
}


template <class T>
class Notifier : public i_Notifier
{
public:

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

// protected: (should be used by T class only)

                        Notifier( T* c )                        { cber_ = c; }

    inline void         trigger( CallBacker* c=0, CallBacker* exclude=0 )
                        { cbs_.doCall(c ? c : cber_, &enabled_, exclude); }

};


mClass NotifyStopper 
{
public:
                        NotifyStopper( NotifierAccess& n ) 
                            : thenotif(n)
                            , oldstatus( n.doEnable(false) )
                        {}

    inline              ~NotifyStopper()
                        { restore(); }

    inline void         enable()                { thenotif.doEnable(false); }
    inline void         disable()               { thenotif.doEnable(true); }
    inline void         restore()               { thenotif.doEnable(oldstatus);}

protected:

    NotifierAccess&     thenotif;
    bool                oldstatus;
};


template <class T,class C>
class CNotifier : public i_Notifier
{
public:

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

// almost protected (as above):

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

    inline void         trigger( CallBacker* cb=0 )
                        {
                            if( !enabled_ ) return; 
                            C c;
                            trigger(c,cb);
                        }

    inline void         trigger( C c, CallBacker* cb=0 )
                        {
                            if( !enabled_ ) return; 
                            CBCapsule<C> caps( c, cb ? cb : cber_ );
                            cbs_.doCall( &caps, &enabled_ );
                        }
};



#endif