---

CTBcallbackR.hxx

Go to the documentation of this file.

#ifndef _CTBcallbackR_HXX
#define _CTBcallbackR_HXX 1

/*----------------------------------------------------------------------------*/
/* C Tool Box: Designed and implemented by:                                   */
/*    Walter F.J. Mueller   Gesellschaft fuer Schwerionenforschung (GSI)      */
/*                          Planckstrasse 1, D-64291 Darmstadt, Germany       */
/*                  Email:  W.F.J.Mueller@gsi.de                              */
/*                  WWW:    http://www-kp3.gsi.de/www/kp3/people/mueller.html */
/*------------------------------------------+---------------------------------*/
 
#include "CTBvector.hxx"
#include "CTBcallbackBase.hxx"

template <class TR>
class CTBcallbackSource0R : public CTBcallbackSourceBase {
  public:
    void            operator()(CTBvector<TR>& res);
};

template <class T, class TR>
class CTBcallbackTarget0R : public CTBcallbackTargetBase {
  public:
                    CTBcallbackTarget0R();
                    CTBcallbackTarget0R(const CTBcallbackTarget0R<T,TR>& rhs);

                    CTBcallbackTarget0R(T* p_this, TR (T::* o_func)());
                    CTBcallbackTarget0R(const CTBcallbackTarget0R<T,TR>& rhs,
                                        T* p_this, TR (T::* o_func)());

    void            Configure(T* p_this, TR (T::* o_func)());
    void            Connect(CTBcallbackSource0R<TR>& source);
    void            Disconnect(CTBcallbackSource0R<TR>& source);
  
  private:
    virtual void    Execute(void* p_arg) const;

  private:
    T*              mp_this;
    TR              (T::* mo_func)();
};

template <class TR>
class CTBcallbackArg0R {
  public:
                    CTBcallbackArg0R(CTBvector<TR>& res);
  public:
    CTBvector<TR>&  m_res;
};

//##############################################################################
template <class TR, class T1>
class CTBcallbackSource1R : public CTBcallbackSourceBase {
  public:
    void            operator()(CTBvector<TR>& res, T1 p1);
};

template <class T, class TR, class T1>
class CTBcallbackTarget1R : public CTBcallbackTargetBase {
  public:
                    CTBcallbackTarget1R();
                    CTBcallbackTarget1R(
                      const CTBcallbackTarget1R<T,TR,T1>& rhs);

                    CTBcallbackTarget1R(T* p_this, TR (T::* o_func)(T1));
                    CTBcallbackTarget1R(
                      const CTBcallbackTarget1R<T,TR,T1>& rhs,
                      T* p_this, TR (T::* o_func)(T1));

    void            Configure(T* p_this, TR (T::* o_func)(T1));
    void            Connect(CTBcallbackSource1R<TR,T1>& source);
    void            Disconnect(CTBcallbackSource1R<TR,T1>& source);
  
  private:
    virtual void    Execute(void* p_arg) const;

  private:
    T*              mp_this;
    TR              (T::* mo_func)(T1);
};

template <class TR, class T1>
class CTBcallbackArg1R {
  public:
                    CTBcallbackArg1R(CTBvector<TR>& res, T1 p1);
  public:
    CTBvector<TR>&  m_res;
    T1              m_p1;
};

// the implementation is fully inlined and always included here
#include "CTBcallbackR.icc"

#endif

---