TPSocket

class TPSocket : public TSocket

    private:

               TPSocket TPSocket(TSocket** pSockets, Int_t size)
               TPSocket TPSocket(const TPSocket&)
      virtual Option_t* GetOption() const
                   void Init(Int_t tcpwindowsize)
                   void operator=(const TPSocket&)

    public:

                  TPSocket TPSocket(TInetAddress address, const char* service, Int_t size, Int_t tcpwindowsize = -1)
                  TPSocket TPSocket(TInetAddress address, Int_t port, Int_t size, Int_t tcpwindowsize = -1)
                  TPSocket TPSocket(const char* host, const char* service, Int_t size, Int_t tcpwindowsize = -1)
                  TPSocket TPSocket(const char* host, Int_t port, Int_t size, Int_t tcpwindowsize = -1)
              virtual void ~TPSocket()
            static TClass* Class()
              virtual void Close(Option_t* opt)
             virtual Int_t GetDescriptor() const
                     Int_t GetErrorCode() const
      virtual TInetAddress GetLocalInetAddress()
             virtual Int_t GetOption(ESockOptions opt, Int_t& val)
                     Int_t GetSize() const
           virtual TClass* IsA() const
            virtual Bool_t IsValid() const
             virtual Int_t Recv(TMessage*& mess)
             virtual Int_t Recv(Int_t& status, Int_t& kind)
             virtual Int_t Recv(char* mess, Int_t max)
             virtual Int_t Recv(char* mess, Int_t max, Int_t& kind)
             virtual Int_t RecvRaw(void* buffer, Int_t length, ESendRecvOptions opt)
             virtual Int_t Send(const TMessage& mess)
             virtual Int_t Send(Int_t kind)
             virtual Int_t Send(Int_t status, Int_t kind)
             virtual Int_t Send(const char* mess, Int_t kind = kMESS_STRING)
             virtual Int_t SendRaw(const void* buffer, Int_t length, ESendRecvOptions opt)
             virtual Int_t SetOption(ESockOptions opt, Int_t val)
              virtual void ShowMembers(TMemberInspector& insp, char* parent)
              virtual void Streamer(TBuffer& b)
                      void StreamerNVirtual(TBuffer& b)

  Data Members
    private:

      TSocket** fSockets         array of parallel sockets
      TMonitor* fWriteMonitor    monitor write on parallel sockets
      TMonitor* fReadMonitor     monitor read from parallel sockets
          Int_t fSize            number of parallel sockets
         Int_t* fWriteBytesLeft  bytes left to write for specified socket
         Int_t* fReadBytesLeft   bytes left to read for specified socket
         char** fWritePtr        pointer to write buffer for specified socket
         char** fReadPtr         pointer to read buffer for specified socket

    protected:

Class Description

                                                                      
 TPSocket                                                             
                                                                      
 This class implements parallel client sockets. A parallel socket is  
 an endpoint for communication between two machines. It is parallel   
 because several TSockets are open at the same time to the same       
 destination. This especially speeds up communication over Big Fat    
 Pipes (i.e. high bandwidth, high latency WAN connections).           
                                                                      

 Create a parallel socket. Connect to the named service at address addr.
 Use tcpwindowsize to specify the size of the receive buffer, it has
 to be specified here to make sure the window scale option is set (for
 tcpwindowsize > 65KB and for platforms supporting window scaling).
 Returns when connection has been accepted by remote side. Use IsValid()
 to check the validity of the socket. Every socket is added to the TROOT
 sockets list which will make sure that any open sockets are properly
 closed on program termination.

 Create a parallel socket. Connect to the specified port # at address addr.
 Use tcpwindowsize to specify the size of the receive buffer, it has
 to be specified here to make sure the window scale option is set (for
 tcpwindowsize > 65KB and for platforms supporting window scaling).
 Returns when connection has been accepted by remote side. Use IsValid()
 to check the validity of the socket. Every socket is added to the TROOT
 sockets list which will make sure that any open sockets are properly
 closed on program termination.

 Create a parallel socket. Connect to named service on the remote host.
 Use tcpwindowsize to specify the size of the receive buffer, it has
 to be specified here to make sure the window scale option is set (for
 tcpwindowsize > 65KB and for platforms supporting window scaling).
 Returns when connection has been accepted by remote side. Use IsValid()
 to check the validity of the socket. Every socket is added to the TROOT
 sockets list which will make sure that any open sockets are properly
 closed on program termination.

 Create a parallel socket. Connect to specified port # on the remote host.
 Use tcpwindowsize to specify the size of the receive buffer, it has
 to be specified here to make sure the window scale option is set (for
 tcpwindowsize > 65KB and for platforms supporting window scaling).
 Returns when connection has been accepted by remote side. Use IsValid()
 to check the validity of the socket. Every socket is added to the TROOT
 sockets list which will make sure that any open sockets are properly
 closed on program termination.

 Create a parallel socket. This ctor is called by TPServerSocket.

 Cleanup the parallel socket.

 Close a parallel socket. If option is "force", calls shutdown(id,2) to
 shut down the connection. This will close the connection also
 for the parent of this process. Also called via the dtor (without
 option "force", call explicitely Close("force") if this is desired).

 Create a parallel socket to the specified host.

 Return internet address of local host to which the socket is bound.
 In case of error TInetAddress::IsValid() returns kFALSE.

 Send a TMessage object. Returns the number of bytes in the TMessage
 that were sent and -1 in case of error. In case the TMessage::What
 has been or'ed with kMESS_ACK, the call will only return after having
 received an acknowledgement, making the sending process synchronous.
 Returns -4 in case of kNoBlock and errno == EWOULDBLOCK.

 Send a raw buffer of specified length. Returns the number of bytes
 send and -1 in case of error.

 Receive a TMessage object. The user must delete the TMessage object.
 Returns length of message in bytes (can be 0 if other side of connection
 is closed) or -1 in case of error or -4 in case a non-blocking socket would
 block (i.e. there is nothing to be read). In those case mess == 0.

 Send a raw buffer of specified length. Returns the number of bytes
 sent or -1 in case of error.

 Set socket options.

 Get socket options. Returns -1 in case of error.

 Returns error code. Meaning depends on context where it is called.
 If no error condition returns 0 else a value < 0.

Inline Functions

               void operator=(const TPSocket&)
           TPSocket TPSocket(const char* host, Int_t port, Int_t size, Int_t tcpwindowsize = -1)
              Int_t GetDescriptor() const
              Int_t Send(Int_t kind)
              Int_t Send(Int_t status, Int_t kind)
              Int_t Send(const char* mess, Int_t kind = kMESS_STRING)
              Int_t Recv(Int_t& status, Int_t& kind)
              Int_t Recv(char* mess, Int_t max)
              Int_t Recv(char* mess, Int_t max, Int_t& kind)
             Bool_t IsValid() const
              Int_t GetOption(ESockOptions opt, Int_t& val)
              Int_t GetSize() const
            TClass* Class()
            TClass* IsA() const
               void ShowMembers(TMemberInspector& insp, char* parent)
               void Streamer(TBuffer& b)
               void StreamerNVirtual(TBuffer& b)