---

tevent.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/tevent.h#1 $
 */

#ifndef _T_EVENT_HH
#define _T_EVENT_HH

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

namespace SmartSockets {

  class T_IPCX_API TipcEventException : public TipcException {

  public:
    TipcEventException () {};

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

  class T_IPCX_API MessageEvent;
  class T_IPCX_API SocketEvent;
  class T_IPCX_API UserEvent;
  class T_IPCX_API ConnEvent;
  class T_IPCX_API TimerEvent;
  class T_IPCX_API TipcMsg;
  class T_IPCX_API TipcConn;
  class T_IPCX_API TipcSrv;
  class T_IPCX_API TipcDispatcher;

  class T_IPCX_API MessageEventHandler {
  public:

    typedef void (MessageEventHandler::*Handler) (
                                                 MessageEvent& event,
                                                 TipcMsg& msg);


    virtual void onMessage(MessageEvent& event,
                           TipcMsg& msg)
    {
    }
  };


  class T_IPCX_API SocketEventHandler {
  public:
    typedef void (SocketEventHandler::*Handler) (
                                                SocketEvent& event,
                                                sock socketFd,
                                                T_IO_CHECK_MODE checkMode);

    virtual void onSocket(SocketEvent& event,
                          sock socketFd,
                          T_IO_CHECK_MODE checkMode)
    {
    }
  };


  class T_IPCX_API UserEventHandler {
  public:

    typedef void (UserEventHandler::*Handler) (
                                              UserEvent& event,
                                              void* data);


    virtual void onUserEvent(UserEvent& event,
                             void* data)
    {
    }
  };


  class T_IPCX_API ConnEventHandler {
  public:
    typedef void (ConnEventHandler::*Handler) (
                                              ConnEvent& event,
                                              TipcConn& conn,
                                              T_IO_CHECK_MODE checkMode);

    virtual void onConnEvent (ConnEvent& event,
                              TipcConn& conn,
                              T_IO_CHECK_MODE checkMode)
    {
#if 0
      if (checkMode == T_IO_CHECK_READ) {
        TipcMsg* msg = conn.next(T_TIMEOUT_FOREVER);
        if (msg != NULL) {
          conn.process(*msg);
          delete msg;
        }
      }
#endif
    }
  };


  class T_IPCX_API TimerEventHandler {
  public:
    typedef void (TimerEventHandler::*Handler) (
                                               TimerEvent& event,
                                               real8 timerInterval);

    virtual void onTimer(TimerEvent& event,
                         real8 timerInterval)
    {
      printf ("Current time = %f\n", TutGetWallTime());
    }
  };


  class T_IPCX_API TipcEvent {

  public:

    friend class T_IPCX_API TipcDispatcher;
    friend class T_IPCX_API TipcDispatcherTraverser;

  protected:

    TipcEvent()
    : _event (NULL)
    {
    }

    virtual ~TipcEvent() throw()
    {
    }



    void setEvent(T_IPC_EVENT event)
    {
      _event = event;
    }
  public:


    void destroy() throw (TipcException)
    {
      if (_event != NULL) {
        if (!TipcEventDestroy(_event))
          throw TipcEventException();
      }
      delete this;
    }


    TipcDispatcher getDispatcher()
    throw (TipcException);

    operator T_IPC_EVENT() const
    throw ()
    {
      return _event;
    }

    T_IPC_EVENT_TYPE getType() const
    throw (TipcException);


  protected:
    T_IPC_EVENT _event;

  };



  class T_IPCX_API UserEvent: public TipcEvent {
  public:

    friend class T_IPCX_API TipcDispatcher;
    friend class T_IPCX_API TipcDispatcherTraverser;

    const void* getData() throw (TipcException)
    {
      void* data = NULL;
      if (!TipcEventGetData(_event,&data))
        throw TipcEventException();
      return const_cast <const void*> (data);
    }

  private:
    UserEvent(UserEventHandler* handlerObj,
              UserEventHandler::Handler handlerMethod)
    : _handlerObj(handlerObj)
    , _handlerMethod(handlerMethod)
    {
    }

    virtual ~UserEvent() throw()
    {
    }

    UserEventHandler* _handlerObj;
    UserEventHandler::Handler _handlerMethod;
  };

  class T_IPCX_API MessageEvent: public TipcEvent {
  public:

    friend class T_IPCX_API TipcDispatcher;
    friend class T_IPCX_API TipcDispatcherTraverser;
  private:
    MessageEvent(MessageEventHandler* handlerObj,
                 MessageEventHandler::Handler handlerMethod)
    : _handlerObj(handlerObj)
    , _handlerMethod(handlerMethod)
    {
    }
    virtual ~MessageEvent() throw()
    {
    }

    MessageEventHandler* _handlerObj;
    MessageEventHandler::Handler _handlerMethod;
  };


  class T_IPCX_API SocketEvent: public TipcEvent {
  public:

    friend class T_IPCX_API TipcDispatcher;
    friend class T_IPCX_API TipcDispatcherTraverser;

    sock getSocket() throw (TipcException)
    {
      sock socketFd = 0;
      if (!TipcEventGetSocket(_event,&socketFd))
        throw TipcEventException();
      return socketFd;
    }

    T_IO_CHECK_MODE getCheckMode() throw (TipcException)
    {
      T_IO_CHECK_MODE checkMode;
      if (!TipcEventGetCheckMode(_event,&checkMode))
        throw TipcEventException();
      return checkMode;
    }

  private:
    SocketEvent(SocketEventHandler* handlerObj,
                SocketEventHandler::Handler handlerMethod)
    : _handlerObj(handlerObj)
    , _handlerMethod(handlerMethod)
    {
    }

    virtual ~SocketEvent() throw()
    {
    }
    SocketEventHandler* _handlerObj;
    SocketEventHandler::Handler _handlerMethod;
  };


  class T_IPCX_API ConnEvent: public TipcEvent {
  public:

    friend class T_IPCX_API TipcDispatcher;
    friend class T_IPCX_API TipcDispatcherTraverser;

    T_IO_CHECK_MODE getCheckMode() throw (TipcException)
    {
      T_IO_CHECK_MODE checkMode;
      if (!TipcEventGetCheckMode(_event,&checkMode))
        throw TipcEventException();
      return checkMode;
    }

  private:
    ConnEvent(ConnEventHandler* handlerObj,
              ConnEventHandler::Handler handlerMethod)
    : _handlerObj(handlerObj)
    , _handlerMethod(handlerMethod)
    {
    }

    virtual ~ConnEvent() throw()
    {
    }

    ConnEventHandler* _handlerObj;
    ConnEventHandler::Handler _handlerMethod;
  };

  class T_IPCX_API TimerEvent: public TipcEvent {
  public:

    friend class T_IPCX_API TipcDispatcher;
    friend class T_IPCX_API TipcDispatcherTraverser;

    real8 getTimerInterval() throw (TipcException)
    {
      real8 interval;
      if (!TipcEventGetInterval(_event,&interval))
        throw TipcEventException();
      return interval;
    }

    void setTimerInterval(real8 interval) throw (TipcException)
    {
      if (!TipcEventSetInterval(_event,interval))
        throw TipcEventException();
    }

  private:
    TimerEvent(TimerEventHandler* handlerObj,
               TimerEventHandler::Handler handlerMethod)
    : _handlerObj(handlerObj)
    , _handlerMethod(handlerMethod)
    {
    }
    virtual ~TimerEvent() throw()
    {
    }

    TimerEventHandler* _handlerObj;
    TimerEventHandler::Handler _handlerMethod;
  };

} //namespace SmartSockets

#endif //_T_EVENT_HH

---