ACE_SOCK_Stream Class Reference

Defines the methods in the ACE_SOCK_Stream abstraction. More...

#include <SOCK_Stream.h>

Inheritance diagram for ACE_SOCK_Stream:

Inheritance graph
[legend]
Collaboration diagram for ACE_SOCK_Stream:

Collaboration graph
[legend]
List of all members.

Public Types

typedef ACE_INET_Addr PEER_ADDR

Public Member Functions

 ACE_SOCK_Stream (void)
 Constructor.

 ACE_SOCK_Stream (ACE_HANDLE h)
 Constructor (sets the underlying ACE_HANDLE with h).

 ~ACE_SOCK_Stream (void)
 Destructor.

ssize_t send_urg (const void *ptr, size_t len=sizeof(char), const ACE_Time_Value *timeout=0) const
ssize_t recv_urg (void *ptr, size_t len=sizeof(char), const ACE_Time_Value *timeout=0) const
int close_reader (void)
 Close down the reader.

int close_writer (void)
 Close down the writer.

int close (void)
void dump (void) const
 Dump the state of an object.

Counted send/receive methods
The counted send/receive methods attempt to send a specified number of bytes even if they must block and retry the operation in order to transfer the entire amount. The time spent blocking for the entire transfer can be limited by a specified ACE_Time_Value object which is a relative time (i.e., a fixed amount of time, not an absolute time of day). These methods return the count of transferred bytes, or -1 if an error occurs or the operation times out. In error or timeout situations it's possible that some data was transferred before the error or timeout. The bytes_transferred parameter is used to obtain the count of bytes transferred before the error or timeout occurred. If the total specified number of bytes is transferred without error, the method return value should equal the value of bytes_transferred.

ssize_t recv_n (void *buf, size_t len, int flags, const ACE_Time_Value *timeout=0, size_t *bytes_transferred=0) const
 Try to recv exactly len bytes into buf from the connected socket.

ssize_t recv_n (void *buf, size_t len, const ACE_Time_Value *timeout=0, size_t *bytes_transferred=0) const
 Try to recv exactly len bytes into buf from the connected socket.

ssize_t recvv_n (iovec iov[], int iovcnt, const ACE_Time_Value *timeout=0, size_t *bytes_transferred=0) const
 Receive an iovec of size iovcnt from the connected socket.

ssize_t send_n (const void *buf, size_t len, int flags, const ACE_Time_Value *timeout=0, size_t *bytes_transferred=0) const
 Try to send exactly len bytes from buf>to the connection socket.

ssize_t send_n (const void *buf, size_t len, const ACE_Time_Value *timeout=0, size_t *bytes_transferred=0) const
 Try to send exactly len bytes from buf to the connected socket.

ssize_t send_n (const ACE_Message_Block *message_block, const ACE_Time_Value *timeout=0, size_t *bytes_transferred=0) const
ssize_t sendv_n (const iovec iov[], int iovcnt, const ACE_Time_Value *timeout=0, size_t *bytes_transferred=0) const
 Send an iovec of size iovcnt to the connected socket.


Public Attributes

 ACE_ALLOC_HOOK_DECLARE
 Declare the dynamic allocation hooks.


Detailed Description

Defines the methods in the ACE_SOCK_Stream abstraction.

This adds additional wrapper methods atop the ACE_SOCK_IO class.

is the buffer to write from or receive into. is the number of bytes to transfer. The parameter in the following methods indicates how long to blocking trying to transfer data. If == 0, then the call behaves as a normal send/recv call, i.e., for blocking sockets, the call will block until action is possible; for non-blocking sockets, EWOULDBLOCK will be returned if no action is immediately possible. If != 0, the call will wait for data to arrive no longer than the relative time specified in *. The "_n()" I/O methods keep looping until all the data has been transferred. These methods also work for sockets in non-blocking mode i.e., they keep looping on EWOULDBLOCK. is used to make sure we keep making progress, i.e., the same timeout value is used for every I/O operation in the loop and the timeout is not counted down. The return values for the "*_n()" methods match the return values from the non "_n()" methods and are specified as follows:

On partial transfers, i.e., if any data is transferred before timeout/error/EOF, will contain the number of bytes transferred. Methods with parameter are I/O vector variants of the I/O operations. Methods with the extra argument will always result in getting called. Methods without the extra argument will result in getting called on Win32 platforms, and getting called on non-Win32 platforms.

Definition at line 71 of file SOCK_Stream.h.


Member Typedef Documentation

typedef ACE_INET_Addr ACE_SOCK_Stream::PEER_ADDR
 

Reimplemented in ACE_LSOCK_Stream.

Definition at line 171 of file SOCK_Stream.h.


Constructor & Destructor Documentation

ACE_BEGIN_VERSIONED_NAMESPACE_DECL ACE_INLINE ACE_SOCK_Stream::ACE_SOCK_Stream void   ) 
 

Constructor.

Definition at line 11 of file SOCK_Stream.inl.

00012 {
00013   // ACE_TRACE ("ACE_SOCK_Stream::ACE_SOCK_Stream");
00014 }

ACE_INLINE ACE_SOCK_Stream::ACE_SOCK_Stream ACE_HANDLE  h  ) 
 

Constructor (sets the underlying ACE_HANDLE with h).

Definition at line 17 of file SOCK_Stream.inl.

References ACE_IPC_SAP::set_handle().

00018 {
00019   // ACE_TRACE ("ACE_SOCK_Stream::ACE_SOCK_Stream");
00020   this->set_handle (h);
00021 }

ACE_INLINE ACE_SOCK_Stream::~ACE_SOCK_Stream void   ) 
 

Destructor.

Definition at line 24 of file SOCK_Stream.inl.

00025 {
00026   // ACE_TRACE ("ACE_SOCK_Stream::~ACE_SOCK_Stream");
00027 }


Member Function Documentation

int ACE_SOCK_Stream::close void   ) 
 

Close down the socket (we need this to make things work correctly on Win32, which requires use to do a close_writer() before doing the close to avoid losing data).

Reimplemented from ACE_SOCK.

Definition at line 24 of file SOCK_Stream.cpp.

References ACE_SOCK::close().

Referenced by ACE_SOCK_Connector::complete(), ACE_Service_Manager::handle_input(), ACE_Pipe::open(), ACE_SOCK_Connector::shared_connect_finish(), ACE_SOCK_Connector::shared_connect_start(), and ACE_Name_Proxy::~ACE_Name_Proxy().

00025 {
00026   // Close down the socket.
00027   return ACE_SOCK::close ();
00028 }

ACE_INLINE int ACE_SOCK_Stream::close_reader void   ) 
 

Close down the reader.

Definition at line 30 of file SOCK_Stream.inl.

References ACE_SHUTDOWN_READ, ACE_TRACE, ACE_IPC_SAP::get_handle(), and ACE_OS::shutdown().

00031 {
00032   ACE_TRACE ("ACE_SOCK_Stream::close_reader");
00033   if (this->get_handle () != ACE_INVALID_HANDLE)
00034     return ACE_OS::shutdown (this->get_handle (), ACE_SHUTDOWN_READ);
00035   else
00036     return 0;
00037 }

ACE_INLINE int ACE_SOCK_Stream::close_writer void   ) 
 

Close down the writer.

Definition at line 42 of file SOCK_Stream.inl.

References ACE_SHUTDOWN_WRITE, ACE_TRACE, ACE_IPC_SAP::get_handle(), and ACE_OS::shutdown().

00043 {
00044   ACE_TRACE ("ACE_SOCK_Stream::close_writer");
00045   if (this->get_handle () != ACE_INVALID_HANDLE)
00046     return ACE_OS::shutdown (this->get_handle (), ACE_SHUTDOWN_WRITE);
00047   else
00048     return 0;
00049 }

ACE_BEGIN_VERSIONED_NAMESPACE_DECL void ACE_SOCK_Stream::dump void   )  const
 

Dump the state of an object.

Reimplemented from ACE_SOCK_IO.

Reimplemented in ACE_LSOCK_Stream.

Definition at line 16 of file SOCK_Stream.cpp.

References ACE_TRACE.

Referenced by ACE_Name_Proxy::dump(), and ACE_LSOCK_Stream::dump().

00017 {
00018 #if defined (ACE_HAS_DUMP)
00019   ACE_TRACE ("ACE_SOCK_Stream::dump");
00020 #endif /* ACE_HAS_DUMP */
00021 }

ACE_INLINE ssize_t ACE_SOCK_Stream::recv_n void *  buf,
size_t  len,
const ACE_Time_Value timeout = 0,
size_t *  bytes_transferred = 0
const
 

Try to recv exactly len bytes into buf from the connected socket.

Definition at line 68 of file SOCK_Stream.inl.

References ACE_TRACE, and ACE::recv_n().

00072 {
00073   ACE_TRACE ("ACE_SOCK_Stream::recv_n");
00074   return ACE::recv_n (this->get_handle (),
00075                       buf,
00076                       len,
00077                       timeout,
00078                       bytes_transferred);
00079 }

ACE_INLINE ssize_t ACE_SOCK_Stream::recv_n void *  buf,
size_t  len,
int  flags,
const ACE_Time_Value timeout = 0,
size_t *  bytes_transferred = 0
const
 

Try to recv exactly len bytes into buf from the connected socket.

Definition at line 52 of file SOCK_Stream.inl.

References ACE_TRACE, and ACE::recv_n().

Referenced by ACE_Name_Proxy::request_reply().

00057 {
00058   ACE_TRACE ("ACE_SOCK_Stream::recv_n");
00059   return ACE::recv_n (this->get_handle (),
00060                       buf,
00061                       len,
00062                       flags,
00063                       timeout,
00064                       bytes_transferred);
00065 }

ACE_INLINE ssize_t ACE_SOCK_Stream::recv_urg void *  ptr,
size_t  len = sizeof(char),
const ACE_Time_Value timeout = 0
const
 

Definition at line 165 of file SOCK_Stream.inl.

References ACE_TRACE, and ACE::recv().

00168 {
00169   ACE_TRACE ("ACE_SOCK_Stream::recv_urg");
00170   return ACE::recv (this->get_handle (),
00171                     ptr,
00172                     len,
00173                     MSG_OOB,
00174                     timeout);
00175 }

ACE_INLINE ssize_t ACE_SOCK_Stream::recvv_n iovec  iov[],
int  iovcnt,
const ACE_Time_Value timeout = 0,
size_t *  bytes_transferred = 0
const
 

Receive an iovec of size iovcnt from the connected socket.

Definition at line 82 of file SOCK_Stream.inl.

References ACE_TRACE, and ACE::recvv_n().

00086 {
00087   ACE_TRACE ("ACE_SOCK_Stream::recvv_n");
00088   return ACE::recvv_n (this->get_handle (),
00089                        iov,
00090                        n,
00091                        timeout,
00092                        bytes_transferred);
00093 }

ACE_INLINE ssize_t ACE_SOCK_Stream::send_n const ACE_Message_Block message_block,
const ACE_Time_Value timeout = 0,
size_t *  bytes_transferred = 0
const
 

Send all the message_block's chained through their next and cont pointers. This call uses the underlying OS gather-write operation to reduce the domain-crossing penalty.

Definition at line 140 of file SOCK_Stream.inl.

References ACE_TRACE, and ACE::send_n().

00143 {
00144   ACE_TRACE ("ACE_SOCK_Stream::send_n");
00145   return ACE::send_n (this->get_handle (),
00146                       message_block,
00147                       timeout,
00148                       bytes_transferred);
00149 }

ACE_INLINE ssize_t ACE_SOCK_Stream::send_n const void *  buf,
size_t  len,
const ACE_Time_Value timeout = 0,
size_t *  bytes_transferred = 0
const
 

Try to send exactly len bytes from buf to the connected socket.

Definition at line 112 of file SOCK_Stream.inl.

References ACE_TRACE, and ACE::send_n().

00116 {
00117   ACE_TRACE ("ACE_SOCK_Stream::send_n");
00118   return ACE::send_n (this->get_handle (),
00119                       buf,
00120                       len,
00121                       timeout,
00122                       bytes_transferred);
00123 }

ACE_INLINE ssize_t ACE_SOCK_Stream::send_n const void *  buf,
size_t  len,
int  flags,
const ACE_Time_Value timeout = 0,
size_t *  bytes_transferred = 0
const
 

Try to send exactly len bytes from buf>to the connection socket.

Definition at line 96 of file SOCK_Stream.inl.

References ACE_TRACE, and ACE::send_n().

Referenced by ACE_Service_Manager::list_services(), ACE_Service_Manager::reconfigure_services(), ACE_Remote_Token_Proxy::request_reply(), ACE_Name_Proxy::request_reply(), and ACE_Name_Proxy::send_request().

00101 {
00102   ACE_TRACE ("ACE_SOCK_Stream::send_n");
00103   return ACE::send_n (this->get_handle (),
00104                       buf,
00105                       len,
00106                       flags,
00107                       timeout,
00108                       bytes_transferred);
00109 }

ACE_INLINE ssize_t ACE_SOCK_Stream::send_urg const void *  ptr,
size_t  len = sizeof(char),
const ACE_Time_Value timeout = 0
const
 

Definition at line 152 of file SOCK_Stream.inl.

References ACE_TRACE, and ACE::send().

00155 {
00156   ACE_TRACE ("ACE_SOCK_Stream::send_urg");
00157   return ACE::send (this->get_handle (),
00158                     ptr,
00159                     len,
00160                     MSG_OOB,
00161                     timeout);
00162 }

ACE_INLINE ssize_t ACE_SOCK_Stream::sendv_n const iovec  iov[],
int  iovcnt,
const ACE_Time_Value timeout = 0,
size_t *  bytes_transferred = 0
const
 

Send an iovec of size iovcnt to the connected socket.

Definition at line 126 of file SOCK_Stream.inl.

References ACE_TRACE, and ACE::sendv_n().

00130 {
00131   ACE_TRACE ("ACE_SOCK_Stream::sendv_n");
00132   return ACE::sendv_n (this->get_handle (),
00133                        iov,
00134                        n,
00135                        timeout,
00136                        bytes_transferred);
00137 }


Member Data Documentation

ACE_SOCK_Stream::ACE_ALLOC_HOOK_DECLARE
 

Declare the dynamic allocation hooks.

Reimplemented from ACE_SOCK_IO.

Reimplemented in ACE_LSOCK_Stream.

Definition at line 177 of file SOCK_Stream.h.


The documentation for this class was generated from the following files:
Generated on Thu Nov 9 11:30:01 2006 for ACE by doxygen 1.3.6