ACE 6.0.3
Classes | Public Member Functions | Protected Attributes | Private Member Functions
ACE_Asynch_Write_Stream Class Reference

This class is a factory for initiating asynchronous writes on a connected TCP/IP stream. This class forwards all methods to its implementation class. More...

#include <Asynch_IO.h>

Inheritance diagram for ACE_Asynch_Write_Stream:
Inheritance graph
[legend]
Collaboration diagram for ACE_Asynch_Write_Stream:
Collaboration graph
[legend]

List of all members.

Classes

class  Result
 This is that class which will be passed back to the ACE_Handler when the asynchronous write completes. This class forwards all the methods to the implementation class. More...

Public Member Functions

 ACE_Asynch_Write_Stream (void)
 A do nothing constructor.
virtual ~ACE_Asynch_Write_Stream (void)
 Destructor.
int open (ACE_Handler &handler, ACE_HANDLE handle=ACE_INVALID_HANDLE, const void *completion_key=0, ACE_Proactor *proactor=0)
int write (ACE_Message_Block &message_block, size_t bytes_to_write, const void *act=0, int priority=0, int signal_number=ACE_SIGRTMIN)
int writev (ACE_Message_Block &message_block, size_t bytes_to_write, const void *act=0, int priority=0, int signal_number=ACE_SIGRTMIN)
virtual ACE_Asynch_Operation_Implimplementation (void) const

Protected Attributes

ACE_Asynch_Write_Stream_Implimplementation_
 Implementation class that all methods will be forwarded to.

Private Member Functions

void operator= (const ACE_Asynch_Write_Stream &)
 ACE_Asynch_Write_Stream (const ACE_Asynch_Write_Stream &)

Detailed Description

This class is a factory for initiating asynchronous writes on a connected TCP/IP stream. This class forwards all methods to its implementation class.

Once open() is called, multiple asynchronous writes can be started using this class. An ACE_Asynch_Write_Stream::Result will be passed to the ACE_Handler::handle_write_stream() method on the opened ACE_Handler object when the asynchronous write completes.


Constructor & Destructor Documentation

ACE_Asynch_Write_Stream::ACE_Asynch_Write_Stream ( void  )

A do nothing constructor.

ACE_Asynch_Write_Stream::~ACE_Asynch_Write_Stream ( void  ) [virtual]

Destructor.

ACE_Asynch_Write_Stream::ACE_Asynch_Write_Stream ( const ACE_Asynch_Write_Stream ) [private]

Member Function Documentation

ACE_Asynch_Operation_Impl * ACE_Asynch_Write_Stream::implementation ( void  ) const [virtual]

Return the underlying implementation class.

Todo:
(this should be protected...)

Implements ACE_Asynch_Operation.

Reimplemented in ACE_Asynch_Write_File.

int ACE_Asynch_Write_Stream::open ( ACE_Handler handler,
ACE_HANDLE  handle = ACE_INVALID_HANDLE,
const void *  completion_key = 0,
ACE_Proactor proactor = 0 
)

Initializes the factory with information which will be used with each asynchronous operation.

Parameters:
handlerACE_Handler to be notified when operations initiated via this factory complete. The handle_write_stream() method will be called on this object.
handleThe socket handle to initiate write operations on. If handle is ACE_INVALID_HANDLE, ACE_Handler::handle() will be called on handler to get the handle value.
completion_keyA token that is passed to the completion handler.
proactorThe ACE_Proactor object which will control operation completion and dispatching the results to handler. If this is 0, the process's singleton ACE_Proactor will be used.
Return values:
0for success.
-1for failure; consult errno for further information.

Reimplemented from ACE_Asynch_Operation.

Reimplemented in ACE_Asynch_Write_File.

void ACE_Asynch_Write_Stream::operator= ( const ACE_Asynch_Write_Stream ) [private]
int ACE_Asynch_Write_Stream::write ( ACE_Message_Block message_block,
size_t  bytes_to_write,
const void *  act = 0,
int  priority = 0,
int  signal_number = ACE_SIGRTMIN 
)

Initiates an asynchronous write on a socket. If the operation completes the ACE_Handler object registered in open() will receive a completion callback via its handle_write_stream() method.

Parameters:
bytes_to_writeThe number of bytes to write.
message_blockThe ACE_Message_Block containing data to write. Data is written to the socket beginning at the block's rd_ptr. Upon successful completion of the write operation, the message_block rd_ptr is updated to reflect the data that was written.
actToken that is passed through to the completion handler.
priorityPriority of the operation. This argument only has an affect on POSIX4-Unix. Works like nice in Unix; negative values are not allowed. 0 means priority of the operation same as the process priority. 1 means priority of the operation is one less than the process, and so forth.
signal_numberThe POSIX4 real-time signal number to be used for the operation. signal_number ranges from ACE_SIGRTMIN to ACE_SIGRTMAX. This argument is not used on other platforms.
Return values:
0for success, and the handle_write_stream associated with the opened ACE_Handler will be called. An instance of ACE_Asynch_Write_Stream::Result will be passed to the completion handler.
-1for failure; consult errno for further information.
int ACE_Asynch_Write_Stream::writev ( ACE_Message_Block message_block,
size_t  bytes_to_write,
const void *  act = 0,
int  priority = 0,
int  signal_number = ACE_SIGRTMIN 
)

Same as above but with gather support, through chaining of composite message blocks using the continuation field.


Member Data Documentation

Implementation class that all methods will be forwarded to.

Reimplemented in ACE_Asynch_Write_File.


The documentation for this class was generated from the following files: