lmsg/TransportTCP.hh

/* -*- mode: c++; c-basic-offset: 4; -*- */
#ifndef LMSG_TRANSPORTTCP_HH
#define LMSG_TRANSPORTTCP_HH

#include "lmsg/MsgTypes.hh"

namespace lmsg {
  class Buffer;
  class BufferPool;
  class Message;
  class MsgAddr;
  class MsgHeader;
  class Socket;
  class TCPSocket;

  class TransportTCP {
  public:

    enum openflags {o_none, o_client=1, o_async=2};

    TransportTCP(void);

    ~TransportTCP(void);

    MsgAddr getAddr(void) const;

    bool    isClient(void) const;

    bool    isConnected(void) const;

    bool    isOpen(void) const;

    index_type getDebug(void) const;

    error_type open(mask_type flags, const MsgAddr* addr=0);

    void    close(void);

    error_type connect(const MsgAddr& addr);

    error_type disconnect(void);

    error_type receive(MsgHeader& from, char* b, size_type maxlen, 
                    wtime_type timeout=-1.0);

    error_type receive(MsgHeader& from, Message& msg, wtime_type timeout=-1.0);

    error_type receive(Buffer** Data, wtime_type timeout=-1.0);

    error_type send(const MsgHeader& to, const char* b);

    error_type send(const MsgHeader& to, const Message& b);

    error_type waitMsg(wtime_type Timeout);

    void Purge(void);

    void setBufferPool(BufferPool* pool);

    void setDebug(index_type level);

  private:
    error_type send(Buffer* b);

  private:
    mask_type      mFlags;
    TCPSocket*  mSocket;
    TCPSocket*  mCSocket;
    BufferPool* mBuffPool;
    index_type     mDebug;
  };
} // namespace lmsg

inline bool
lmsg::TransportTCP::isOpen(void) const {
    return (mSocket != 0);
}

inline bool
lmsg::TransportTCP::isClient(void) const {
    return (mFlags & o_client);
}

inline lmsg::index_type
lmsg::TransportTCP::getDebug(void) const {
    return mDebug;
}

#endif // LMSG_TRANSPORTTCP_HH

---