---

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

#ifndef _T_CONN_HH_
#define _T_CONN_HH_

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

namespace SmartSockets {

  class T_IPCX_API TipcMsg;
  class T_IPCX_API TipcMt;

  class T_IPCX_API TipcConnException : public TipcException {

  public:
    TipcConnException () {};

    virtual ~TipcConnException () throw() {}

  };


  class T_IPCX_API TipcConnSearchSelector {
  public:

    typedef bool (TipcConnSearchSelector::* Handler)
    (
    const TipcConn & conn,
    const TipcMsg& msg
    ) ;



    TipcConnSearchSelector();

    void setHandler(Handler cbMethod);

    Handler getHandler();


    virtual ~TipcConnSearchSelector() throw();

    virtual bool onSearch
    (
    const TipcConn & conn,
    const TipcMsg& msg
    )  throw () ;

    static  T_BOOL T_ENTRY searchFuncDelegator
    (
    T_IPC_CONN connection,
    T_IPC_MSG  msg,
    T_PTR arg
    );

  private:

    Handler _cbMethod;

  };

  class T_IPCX_API TipcConn {

  protected:
    T_IPC_CONN _connection;

    bool _destroy_flag;

    TipcConn(bool do_nothing);


    static void T_ENTRY1 errorCbDelegator(T_IPC_CONN connection,
                                          T_IPC_CONN_ERROR_CB_DATA data,
                                          T_CB_ARG arg);


    static void T_ENTRY1 queueCbDelegator(T_IPC_CONN connection,
                                          T_IPC_CONN_QUEUE_CB_DATA data,
                                          T_CB_ARG arg);


    static void T_ENTRY1 messageCbDelegator(T_IPC_CONN connection,
                                            T_IPC_CONN_MSG_CB_DATA data,
                                            T_CB_ARG arg);


    static void T_ENTRY1 readCbDelegator(T_IPC_CONN connection,
                                         T_IPC_CONN_READ_CB_DATA data,
                                         T_CB_ARG arg);


    static void T_ENTRY1 encodeCbDelegator(T_IPC_CONN connection,
                                           T_IPC_CONN_ENCODE_CB_DATA data,
                                           T_CB_ARG arg);


    static void T_ENTRY1 decodeCbDelegator(T_IPC_CONN connection,
                                           T_IPC_CONN_DECODE_CB_DATA data,
                                           T_CB_ARG arg);

  public:
    TipcConn() throw (TipcException);
    TipcConn(T_IPC_CONN connection, bool destroy_flag=true)
    throw (TipcException);

    virtual ~TipcConn() throw();


    operator T_IPC_CONN() const throw()  { return _connection;}

    // The following methods will have TipcSrv equivalents

    virtual bool check(T_IO_CHECK_MODE check_mode, real8 timeout)
    throw (TipcException);

    virtual void flush() throw (TipcException);

    virtual int4 getAutoFlushSize() const throw (TipcException);

    virtual void setAutoFlushSize(int4 auto_flush_size)
    throw (TipcException);

    virtual long getBlockMode() const throw (TipcException);

    virtual void setBlockMode(bool block_mode)
    throw (TipcException);


    virtual real8 getTimeout(T_IPC_TIMEOUT timeout) const
    throw (TipcException);

    virtual void setTimeout(T_IPC_TIMEOUT timeout, real8  value)
    throw (TipcException);

    virtual sock getSocket() const throw (TipcException);

    virtual int4 getNumQueued() const throw (TipcException);

    virtual sock getXtSource() const throw (TipcException);

    virtual void keepAlive() throw (TipcException);

    virtual bool mainLoop(real8 timeout = T_TIMEOUT_FOREVER)
    throw (TipcException);

    virtual void insert(TipcMsg& msg, int4 pos)
    throw (TipcException);

    virtual void process(TipcMsg& msg) throw (TipcException);

    void read(real8 timeout) throw (TipcException);

    virtual void next(TipcMsg& msg, real8 timeout)
    throw (TipcException);


    virtual bool nextEx(TipcMsg& msg, real8 timeout)
    throw (TipcException);


    virtual void search(TipcMsg& msg, TipcConnSearchSelector* selObj,
                        real8 timeout) throw (TipcException);

    virtual void searchType(TipcMsg& msg, TipcMt& mt, real8 timeout)
    throw (TipcException);

    virtual void send(const TipcMsg& msg, bool rtserver_check=FALSE)
    throw (TipcException);

    virtual void sendRpc(TipcMsg& reply_msg, const TipcMsg& call_msg, real8 timeout)
    throw (TipcException);


#if defined(T_OS_WINDOWS)

    /*
     * The Microsoft Visual C++ compilers (4.2 and 5.0, and maybe earlier ones),
     * have a bug that makes it impossible to use references as the last
     * non-variable argument in a varargs list.  So, for Windows, we're just
     * passing the TipcMt object by value (since it's not modified [really
     * ought to be const, cie la vie...]).  Once this bug is fixed, or if
     * you're using some other compiler, this ifdef can be removed.
     */

    virtual void     write(TipcMt mt, ...) throw (TipcException);
    virtual void     writeVa(TipcMt mt, va_list var_arg_list)
    throw (TipcException);
#else
    void     write(TipcMt& mt, ...) throw (TipcException);
    void     writeVa(TipcMt& mt, va_list var_arg_list)
    throw (TipcException);

#endif //T_OS_WINDOWS


    virtual void  print(T_OUT_FUNC func = (T_OUT_FUNC) TutOut) const
    throw (TipcException);

    // CALLBACKS
    virtual CallBack<MessageQueueCallBack> * queueCbCreate(const TipcMt& mt,
                                                           MessageQueueCallBack *,
                                                           void* arg = NULL)
    throw (TipcException);


    virtual CallBack <ErrorCallBack> * errorCbCreate(
                                                    ErrorCallBack * implementor,
                                                    void* arg = NULL)
    throw (TipcException);


    virtual CallBack <MessageCallBack> * encryptCbCreate(
                                                        const TipcMt & mt,
                                                        MessageCallBack * implementor,
                                                        void* arg = NULL)
    throw (TipcException);


    virtual CallBack <MessageCallBack> * decryptCbCreate(
                                                        const TipcMt & mt,
                                                        MessageCallBack * implementor,
                                                        void* arg = NULL)
    throw (TipcException);


    virtual CallBack <MessageCallBack> * defaultCbCreate(
                                                        MessageCallBack * implementor,
                                                        void* arg = NULL)
    throw (TipcException);


    virtual CallBack <MessageCallBack> * processCbCreate(
                                                        const TipcMt & mt,
                                                        MessageCallBack * implementor,
                                                        void* arg = NULL)
    throw (TipcException);


    virtual CallBack <MessageCallBack> * readCbCreate(
                                                     const TipcMt & mt,
                                                     MessageCallBack * implementor,
                                                     void* arg = NULL)
    throw (TipcException);


    virtual CallBack <MessageCallBack> * writeCbCreate(
                                                      const TipcMt & mt,
                                                      MessageCallBack * implementor,
                                                      void* arg = NULL)
    throw (TipcException);


    virtual CallBack <EncodeCallBack> * encodeCbCreate(
                                                      EncodeCallBack * implementor,
                                                      void* arg = NULL)
    throw (TipcException);


    virtual CallBack <DecodeCallBack> * decodeCbCreate(
                                                      DecodeCallBack * impleemntor,
                                                      void* arg = NULL)
    throw (TipcException);


    // ---------------------------------------------------------------------
    //  Starred methods have RTserver (TipcSrv*) overrides
    // ---------------------------------------------------------------------

    virtual const char * getPeerUniqueSubject() const throw (TipcException);

    virtual const char * getNode() const throw (TipcException);

    virtual const char * getUser() const throw (TipcException);

    virtual int4 getPid() const throw (TipcException);

    virtual const char * getArch() const throw (TipcException);

    virtual void lock() throw (TipcException);

    virtual void unlock() throw (TipcException);

    // -- GMD --

    virtual void gmdFileCreate() throw (TipcException);

    virtual void gmdFileDelete() throw (TipcException);

    virtual void gmdResend() throw (TipcException);

    virtual void gmdMsgDelete(TipcMsg& msg) throw (TipcException);

    virtual void gmdMsgResend(TipcMsg& msg) throw (TipcException);

    virtual uint4 getGmdMaxSize() const throw (TipcException);
    virtual void setGmdMaxSize(uint4 gmd_max_size)
    throw (TipcException);

    const char * getGmdDir() const
    throw (TipcException);

    virtual int4 getGmdNumPending() const throw (TipcException);

    virtual int4 trafficGetBytesRecv() const throw (TipcException);

    virtual int8 trafficGetBytesRecv8() const throw (TipcException);

    virtual int4 trafficGetBytesSent() const throw (TipcException);

    virtual int8 trafficGetBytesSent8() const throw (TipcException);

    virtual int4 trafficGetMsgsRecv() const throw (TipcException);

    virtual int8 trafficGetMsgsRecv8() const throw (TipcException);

    virtual int4 trafficGetMsgsSent() const throw (TipcException);

    virtual int8 trafficGetMsgsSent8() const throw (TipcException);

    virtual int4 bufferGetReadSize() const throw (TipcException);

    virtual int4 bufferGetWriteSize() const throw (TipcException);
  };


  class T_IPCX_API TipcConnServer : public TipcConn {

  public:
    TipcConnServer(const char * link_name) throw (TipcException);
    TipcConnServer(T_IPC_CONN connection, bool destroy_flag=TRUE)
    throw (TipcException);

    virtual ~TipcConnServer()  throw();

    virtual TipcConn *accept() throw (TipcException);
  };

  class T_IPCX_API TipcConnClient : public TipcConn {

  public:
    TipcConnClient() throw () {}
    TipcConnClient(const char * link_name) throw (TipcException);
    TipcConnClient(T_IPC_CONN connection, bool destroy_flag=true)
    throw (TipcException);

    virtual ~TipcConnClient() throw();
  };

} // namespace SmartSockets
#endif

---