---

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

#ifndef _T_SERVER_HH_
#define _T_SERVER_HH_

#include <rtworks/ipc.h>
#include <rtworks/types.h>
#include <rtworks/tex.h>
#include <rtworks/tconn.h>
#include <rtworks/tcallbck.h>
//#include <rtworks/txlcl.h>

namespace SmartSockets {

  class T_IPCX_API TipcSrvException : public TipcException {

  public:
    TipcSrvException () {}

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

  class T_IPCX_API TipcSrvSubjTraverser {
  public:

    typedef bool (TipcSrvSubjTraverser::* Handler)
    (
    const char* subjectName
    ) ;



    TipcSrvSubjTraverser();

    void setHandler(Handler cbMethod);

    Handler getHandler();


    virtual ~TipcSrvSubjTraverser() throw();

    virtual bool onTraverse
    (
    const char*     subjectName
    )
    throw () ;

    static  T_PTR T_ENTRY traverseFuncDelegator
    (
    T_STR subj,
    T_STR dummy,
    T_PTR arg
    );

  private:

    Handler _cbMethod;

  };

  class T_IPCX_API TipcSrv : public TipcConnClient {

  private:
    T_IPC_SRV _srv;

  protected:
    static void T_ENTRY1 subjectCbDelegator(T_IPC_CONN connection,
                                            T_IPC_SRV_SUBJECT_CB_DATA data,
                                            T_CB_ARG arg);

    static void T_ENTRY1 openCbDelegator(T_IPC_SRV connection,
                                         T_IPC_SRV_OPEN_CB_DATA data,
                                         T_CB_ARG arg);


    static void T_ENTRY1 closeCbDelegator(T_IPC_SRV connection,
                                          T_IPC_SRV_CLOSE_CB_DATA data,
                                          T_CB_ARG arg);

  public:

    TipcSrv(const char * unique_subject,
            const char * server_names,  /* comma delimited list */
            const char * project = (const char*) T_NULL,
            const char * subject_prefix = (const char*) T_NULL)
    throw (TipcException);

    TipcSrv(const char * name) throw (TipcException);

    TipcSrv (T_IPC_SRV srv,bool destroyFlag = false) throw (TipcException);

    operator T_IPC_CONN() throw (TipcException);

    operator T_IPC_SRV () const throw (TipcException);


    void close(T_IPC_SRV_CONN_STATUS close_status = T_IPC_SRV_CONN_NONE)
    throw (TipcException);

    virtual ~TipcSrv() throw();

    void open(T_IPC_SRV_CONN_STATUS create_status = T_IPC_SRV_CONN_FULL)
    throw (TipcException);

    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 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);

    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 setUsernamePassword(const char * username,
                                     const char * password)
    throw (TipcException);

    virtual void keepAlive() throw (TipcException);

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

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


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

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


    virtual void process(TipcMsg& msg) 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 read(real8 timeout)
    throw (TipcException);

    virtual void send(const TipcMsg& msg,
                      bool check_server_msg_send=true)
    throw (TipcException);

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

    void write(const char * dest, TipcMt& mt,
               bool check_server_msg_send, ...)
    throw (TipcException);

    void writeVa(const char * dest, TipcMt& mt,
                 bool check_server_msg_send,
                 va_list var_arg_list) throw (TipcException);

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

    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 T_IPC_SRV_CONN_STATUS getStatus() const
    throw (TipcException);

    virtual void lock() throw (TipcException);

    virtual void unlock() throw (TipcException);

    virtual int4 getGmdNumPending() const throw (TipcException);

    bool getSubscribe(const char * subject) throw (TipcException);

    void setSubscribe(const char * subject, bool recv_status = true)
    throw (TipcException);

    void traverseSubscribe(TipcSrvSubjTraverser* travObj)
    throw (TipcException);

    static void logAddMt(T_IPC_MT_LOG_TYPE log_type,
                         TipcMt& mt) throw (TipcException);


    static void logRemoveMt(T_IPC_MT_LOG_TYPE log_type,
                            TipcMt& mt) throw (TipcException);


    void setSubscribeStd(bool subscribe_status = true)
    throw (TipcException);


    bool getSubscribeLb(const char * subject, bool *lb_status_return)
    throw (TipcException);

    void setSubscribeLb(const char *  subject, bool subject_status = true,
                        bool lb_status = true) throw (TipcException);

    void subjectLbInit(const char *subject) throw (TipcException);

    virtual void gmdFileCreate() throw (TipcException);

    virtual void gmdFileDelete() throw (TipcException);

    virtual void gmdResend() throw (TipcException);

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

    virtual uint4 getGmdMaxSize() const throw (TipcException);

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

    void gmdMsgServerDelete(TipcMsg& msg) throw (TipcException);

    void gmdMsgStatus(TipcMsg& msg) throw (TipcException);

    void subjectGmdInit(const char * subject) throw (TipcException);

    void setProject(const char* project)
    throw (TipcException);


    const char* getProject() throw (TipcException);

    void setServerNames(const char* server_names)
    throw (TipcException);

    void setServerNamesList(T_STR_LIST server_names_list)
    throw (TipcException);

    T_STR_LIST getServerNamesList()
    throw (TipcException);

    void setDefaultSubjectPrefix(const char* default_subject_prefix)
    throw (TipcException);

    const char* getDefaultSubjectPrefix()
    throw (TipcException);

    void setUniqueSubject(const char * unique_subject)
    throw (TipcException);

    const char* getUniqueSubject()
    throw (TipcException);


    void setSubscribeCache(const char * subj_name, bool status, int4 flags)
    throw (TipcException);

    void setCredentials(int4 auth_policy_id, void * auth_data,
                        int4 auth_data_len) throw (TipcException);

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


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


    virtual CallBack <ConnectionCallBack> * closeCbCreate(
                                                         ConnectionCallBack * implementor,
                                                         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 <MessageCallBack> * subjectCbCreate(
                                                        const char * subject,
                                                        const TipcMt & mt,
                                                        MessageCallBack * implementor,
                                                        void* arg = NULL)
    throw (TipcException);

  };

} // namespace SmartSockets

#endif //_T_SERVER_HH_

---