---

tcallbck.h

/*
 * Copyright (c) 1991-2006 TIBCO Software Inc.
 * All rights reserved.
 * For more information, please contact:
 * TIBCO Software Inc., Palo Alto, California, USA
 *
 * $Id: //dev/packages/tpsi/cpsi/dev/68/src/rtworks/tcallbck.h#1 $
 */

#ifndef _T_CALLBACK_HH_
#define _T_CALLBACK_HH_

#include <rtworks/types.h>
#include <rtworks/tex.h>



namespace SmartSockets {

  class T_IPCX_API TipcConn;
  class T_IPCX_API TipcMsg;
  class T_IPCX_API TipcSrv;


  class T_IPCX_CB_API CallBackException : public Exception 
  {
  public:
    CallBackException() {}

/* Anticipation of a more functional exception class
    CallBackException( int4 ssErrNum = 0, 
                       int4 osErrNum = 0,
                       int4 socketErrNum = 0,
                       int4 cErrNum = 0)
                       : Exception (ssErrNum, osErrNum, socketErrNum, cErrNum)
    {
    }
*/

    virtual ~CallBackException() throw()
    {
    }
  };


  template <class Implementor>
  class T_IPCX_CB_API CallBack 
  {
    friend class T_IPCX_API TipcSrv;
    friend class T_IPCX_API TipcConn;
    friend class T_IPCX_API Option;

  public:

    void destroy() throw (CallBackException) 
    {
      if (is_created()) 
      {
        if (!TutCbDestroy(m_cb))
        {
          throw CallBackException();
        }

        m_cb = 0;
      }

      delete this;
    }

   
    bool is_created() throw () 
    {
      return 0 != m_cb;
    }


    operator T_CB () throw () 
    {
      return m_cb;
    }


    void * getArgument () const throw ()
    {
      return m_argument;
    }


    void setArgument (void* data) throw ()
    {
      m_argument = data;
    }


    T_CB_PRIORITY getPriority () const throw (CallBackException) 
    {
      T_CB_PRIORITY result;

      if (!TutCbGetPriority (m_cb, &result)) 
      {
        throw CallBackException ();
      }

      return result;
    }

    
    void setPriority (T_CB_PRIORITY priority) throw (CallBackException) 
    {
      if (!TutCbSetPriority (m_cb, priority)) 
      {
        throw CallBackException ();
      }
    }


    virtual bool print (T_OUT_FUNC func = (T_OUT_FUNC)TutOut) 
                                                throw (CallBackException) 
    {
      TutCbPrint(m_cb, func);
      return T_TRUE;
    }

  protected:
    /* 
     * The callback structure underlying this object
     */
    T_CB m_cb; 

    /*
     * The call back implementing class.
     */
    Implementor * m_implementor;  
   
    /*
     * The callback handling method within the implementing class.
     */
    typename Implementor::Handler m_handler; 
                                      
    /*
     * The argument data for this object.
     */
    void * m_argument;


    void setTCB (T_CB handle)
    {
      m_cb = handle;
    }

  private:
    CallBack (Implementor * implementor,
              typename Implementor::Handler handler)
      : m_cb (0)
      , m_implementor (implementor)
      , m_handler (handler)
      , m_argument(0)
    { 
    }

    virtual ~CallBack () throw()
    {
    }

    CallBack (const CallBack & callback)
    {
    }
  };


  class T_IPCX_CB_API ConnectionCallBack
  {      
  public:
    enum ConnStatus
    {
      none,/* not connected at all */
      warm,/* warm connection to RTserver */
      full /* full connection to RTserver */
    };

    typedef void (ConnectionCallBack::* Handler) (
      CallBack < ConnectionCallBack > * callBack,
      TipcSrv & connection,
      ConnStatus oldConnStatus,
      ConnStatus newConnStatus);

    ConnectionCallBack () {}

    virtual ~ConnectionCallBack ()  throw() {}


    virtual void onConnection (
      CallBack < ConnectionCallBack > * callBack,
      TipcSrv & connection,
      ConnStatus oldConnStatus,
      ConnStatus newConnStatus); 

  };


  class T_IPCX_CB_API MessageCallBack
  {
  public:
    typedef void (MessageCallBack::* Handler) (
                              CallBack <MessageCallBack> * callBack,
                              TipcMsg & message,
                              TipcConn & connection);

    MessageCallBack () {}
                       

    virtual ~MessageCallBack () throw() {}


    virtual void onMessage (CallBack<MessageCallBack>* callback,
                            TipcMsg & msg,
                            TipcConn & conn); 

/*
    static void dispatchCreateMsgDelegator (T_IPC_DISPATCHER_EVENT event,
                                            void * data,
                                            void * arg);
*/
/*
    static void connMsgDelegator (T_IPC_CONN conn, 
                                  T_IPC_CONN_MSG_CB_DATA data, 
                                  T_CB_ARG arg);
*/

  };


  class T_IPCX_CB_API ErrorCallBack
  {      
  public:
    typedef void (ErrorCallBack::* Handler) (
      CallBack < ErrorCallBack > * callBack,
      Exception & error,
      TipcConn & conn);


    ErrorCallBack() {}


    virtual ~ErrorCallBack() throw() {}


    virtual void onError (
      CallBack <ErrorCallBack> * callBack,
      Exception & error,
      TipcConn & conn); 
  };


  class T_IPCX_CB_API MessageQueueCallBack
  {
  public:
    typedef void (MessageQueueCallBack::* Handler) (
                                 CallBack <MessageQueueCallBack> * callBack,
                                 TipcMsg & message,
                                 TipcConn & connection,
                                 uint4 queuePos,
                                 bool is_insert);

    MessageQueueCallBack() {}

    virtual ~MessageQueueCallBack () throw() {}

    virtual void onMessage (CallBack <MessageQueueCallBack> * callBack,
                            TipcMsg & message,
                            TipcConn & connection,
                            uint4 queuePos,
                            bool is_insert); 
  };



  class T_IPCX_CB_API EncodeCallBack
  {
  public:
    typedef void (EncodeCallBack::* Handler) ( 
                                      CallBack <EncodeCallBack> * callBack,
                                      void * packet,
                                      int4 packetSize,
                                      void * origPacket,
                                      int4 origPacketSize,
                                      TipcMsg & origMessage,
                                      TipcConn & connection);

    EncodeCallBack() {};

    virtual ~EncodeCallBack () throw() {}

    virtual void onMessage (CallBack <EncodeCallBack> * callBack, 
                            void * packet,
                            int4 packetSize,
                            void * origPacket,
                            int4 origPacketSize,
                            TipcMsg & origMessage,
                            TipcConn & connection);
  };



  class T_IPCX_CB_API DecodeCallBack
  {
  public:
    typedef void (DecodeCallBack::* Handler) (
                                CallBack < DecodeCallBack > * callBack,
                                void * packet,
                                int4 packetSize,
                                void * origPacket,
                                int4 origPacketSize,
                                TipcConn & connection);

    DecodeCallBack() {};

    virtual ~DecodeCallBack () throw() {};

    virtual void onMessage (CallBack <DecodeCallBack> * callBack,
                            void * packet,
                            int4 packetSize,
                            void * origPacket,
                            int4 origPacketSize,
                            TipcConn & connection);
  };

}
#endif

---