---

CTBcallback.hxx

Go to the documentation of this file.

#ifndef _CTBcallback_HXX
#define _CTBcallback_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 "CTBcallbackBase.hxx"

class CTBcallbackSource0 : public CTBcallbackSourceBase {
  public:
    void            operator()();
};

template <class T>
class CTBcallbackTarget0 : public CTBcallbackTargetBase {
  public:
                    CTBcallbackTarget0();
                    CTBcallbackTarget0(const CTBcallbackTarget0<T>& rhs);

                    CTBcallbackTarget0(T* p_this, void (T::* o_func)());
                    CTBcallbackTarget0(const CTBcallbackTarget0<T>& rhs,
                                       T* p_this, void (T::* o_func)());

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

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

//##############################################################################

template <class T1>
class CTBcallbackSource1 : public CTBcallbackSourceBase {
  public:
    void            operator()(T1 p1);
};

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

                    CTBcallbackTarget1(T* p_this, void (T::* o_func)(T1));
                    CTBcallbackTarget1(const CTBcallbackTarget1<T,T1>& rhs,
                                       T* p_this, void (T::* o_func)(T1));

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

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

template <class T1>
class CTBcallbackArg1 {
  public:
                    CTBcallbackArg1(T1 p1);
  public:
    T1              m_p1;
};

//##############################################################################

template <class T1, class T2>
class CTBcallbackSource2 : public CTBcallbackSourceBase {
  public:
    void            operator()(T1 p1, T2 p2);
};

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

                    CTBcallbackTarget2(T* p_this, void (T::* o_func)(T1,T2));
                    CTBcallbackTarget2(const CTBcallbackTarget2<T,T1,T2>& rhs,
                                       T* p_this, void (T::* o_func)(T1,T2));

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

  private:
    T*              mp_this;
    void            (T::* mo_func)(T1,T2);
};

template <class T1, class T2>
class CTBcallbackArg2 {
  public:
                    CTBcallbackArg2(T1 p1, T2 p2);
  public:
    T1              m_p1;
    T2              m_p2;
};

//##############################################################################

template <class T1, class T2, class T3>
class CTBcallbackSource3 : public CTBcallbackSourceBase {
  public:
    void            operator()(T1 p1, T2 p2, T3 p3);
};

template <class T, class T1, class T2, class T3>
class CTBcallbackTarget3 : public CTBcallbackTargetBase {
  public:
                    CTBcallbackTarget3();
                    CTBcallbackTarget3(
                      const CTBcallbackTarget3<T,T1,T2,T3>& rhs);

                    CTBcallbackTarget3(T* p_this, void (T::* o_func)(T1,T2,T3));
                    CTBcallbackTarget3(
                      const CTBcallbackTarget3<T,T1,T2,T3>& rhs,
                      T* p_this, void (T::* o_func)(T1,T2,T3));

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

  private:
    T*              mp_this;
    void            (T::* mo_func)(T1,T2,T3);
};

template <class T1, class T2, class T3>
class CTBcallbackArg3 {
  public:
                    CTBcallbackArg3(T1 p1, T2 p2, T3 p3);
  public:
    T1              m_p1;
    T2              m_p2;
    T3              m_p3;
};

//##############################################################################

template <class T1, class T2, class T3, class T4>
class CTBcallbackSource4 : public CTBcallbackSourceBase {
  public:
    void            operator()(T1 p1, T2 p2, T3 p3, T4 p4);
};

template <class T, class T1, class T2, class T3, class T4>
class CTBcallbackTarget4 : public CTBcallbackTargetBase {
  public:
                    CTBcallbackTarget4();
                    CTBcallbackTarget4(
                      const CTBcallbackTarget4<T,T1,T2,T3,T4>& rhs);
                    CTBcallbackTarget4(
                      T* p_this, void (T::* o_func)(T1,T2,T3,T4));
                    CTBcallbackTarget4(
                      const CTBcallbackTarget4<T,T1,T2,T3,T4>& rhs,
                      T* p_this, void (T::* o_func)(T1,T2,T3,T4));

    void            Configure(T* p_this, void (T::* o_func)(T1,T2,T3,T4));
    void            Connect(CTBcallbackSource4<T1,T2,T3,T4>& source);
    void            Disconnect(CTBcallbackSource4<T1,T2,T3,T4>& source);
  
  private:
    virtual void    Execute(void* p_arg) const;

  private:
    T*              mp_this;
    void            (T::* mo_func)(T1,T2,T3,T4);
};

template <class T1, class T2, class T3, class T4>
class CTBcallbackArg4 {
  public:
                    CTBcallbackArg4(T1 p1, T2 p2, T3 p3, T4 p4);
  public:
    T1              m_p1;
    T2              m_p2;
    T3              m_p3;
    T4              m_p4;
};

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

#endif

---