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:

Collaboration diagram for ACE_Asynch_Write_Stream:

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. More...
virtual	~ACE_Asynch_Write_Stream (void)
	Destructor. More...
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_Impl *	implementation (void) const
Public Member Functions inherited from ACE_Asynch_Operation
int	open (ACE_Handler &handler, ACE_HANDLE handle, const void *completion_key, ACE_Proactor *proactor)
int	cancel (void)
ACE_Proactor *	proactor (void) const
	Return the underlying proactor. More...
virtual	~ACE_Asynch_Operation (void)
	Destructor. More...

Protected Attributes
ACE_Asynch_Write_Stream_Impl *	implementation_
	Implementation class that all methods will be forwarded to. More...

Private Member Functions
void	operator= (const ACE_Asynch_Write_Stream &)
	ACE_Asynch_Write_Stream (const ACE_Asynch_Write_Stream &)

Additional Inherited Members
Protected Member Functions inherited from ACE_Asynch_Operation
	ACE_Asynch_Operation (void)
	Constructor. More...
ACE_Proactor *	get_proactor (ACE_Proactor *user_proactor, ACE_Handler &handler) const
	Get a proactor for/from the user. More...

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

handler	ACE_Handler to be notified when operations initiated via this factory complete. The handle_write_stream() method will be called on this object.
handle	The 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_key	A token that is passed to the completion handler.
proactor	The 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

0	for success.
-1	for failure; consult errno for further information.

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_write	The number of bytes to write.
message_block	The 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.
act	Token that is passed through to the completion handler.
priority	Priority 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_number	The 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

0	for 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.
-1	for 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

ACE_Asynch_Write_Stream_Impl* ACE_Asynch_Write_Stream::implementation_

protected

Implementation class that all methods will be forwarded to.

---

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

• Asynch_IO.h
• Asynch_IO.cpp