ACE_Asynch_Write_File Class Reference

This class is a factory for starting off asynchronous writes on a file. This class forwards all methods to its implementation class. More...

#include <Asynch_IO.h>

Inheritance diagram for ACE_Asynch_Write_File:

Collaboration diagram for ACE_Asynch_Write_File:

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

Public Member Functions
	ACE_Asynch_Write_File (void)
	A do nothing constructor. More...
virtual	~ACE_Asynch_Write_File (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, unsigned long offset=0, unsigned long offset_high=0, const void *act=0, int priority=0, int signal_number=ACE_SIGRTMIN)
int	writev (ACE_Message_Block &message_block, size_t bytes_to_write, unsigned long offset=0, unsigned long offset_high=0, const void *act=0, int priority=0, int signal_number=ACE_SIGRTMIN)
virtual ACE_Asynch_Operation_Impl *	implementation (void) const
	Return the underlying implementation class. More...
Public Member Functions inherited from ACE_Asynch_Write_Stream
	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)
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_File_Impl *	implementation_
	Implementation object. More...
Protected Attributes inherited from ACE_Asynch_Write_Stream
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_File &)
	ACE_Asynch_Write_File (const ACE_Asynch_Write_File &)

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 starting off asynchronous writes on a file. This class forwards all methods to its implementation class.

Once {open} is called, multiple asynchronous {write}s can be started using this class. A ACE_Asynch_Write_File::Result will be passed back to the {handler} when the asynchronous writes completes through the {ACE_Handler::handle_write_file} callback. This class differs slightly from ACE_Asynch_Write_Stream as it allows the user to specify an offset for the write.

Constructor & Destructor Documentation

ACE_Asynch_Write_File::ACE_Asynch_Write_File

(

void

)

A do nothing constructor.

ACE_Asynch_Write_File::~ACE_Asynch_Write_File ( void  )

virtual

Destructor.

ACE_Asynch_Write_File::ACE_Asynch_Write_File ( const ACE_Asynch_Write_File &  )

private

Member Function Documentation

ACE_Asynch_Operation_Impl * ACE_Asynch_Write_File::implementation ( void  ) const

virtual

Return the underlying implementation class.

Reimplemented from ACE_Asynch_Write_Stream.

int ACE_Asynch_Write_File::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 call. If ({handle} == ACE_INVALID_HANDLE), {ACE_Handler::handle} will be called on the {handler} to get the correct handle.

void ACE_Asynch_Write_File::operator= ( const ACE_Asynch_Write_File &  )

private

int ACE_Asynch_Write_File::write	(	ACE_Message_Block &	message_block,
		size_t	bytes_to_write,
		unsigned long	offset = 0,
		unsigned long	offset_high = 0,
		const void *	act = 0,
		int	priority = 0,
		int	signal_number = ACE_SIGRTMIN
	)

This starts off an asynchronous write. Upto {bytes_to_write} will be written from the {message_block}, starting at the block's {rd_ptr}. The write will go to the file, starting {offset} bytes from the beginning of the file. Priority of the operation is specified by {priority}. On POSIX4-Unix, this is supported. 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 process. And so forth. On Win32, this is a no-op. {signal_number} is the POSIX4 real-time signal number to be used for the operation. {signal_number} ranges from ACE_SIGRTMIN to ACE_SIGRTMAX. This argument is a no-op on non-POSIX4 systems.

int ACE_Asynch_Write_File::writev	(	ACE_Message_Block &	message_block,
		size_t	bytes_to_write,
		unsigned long	offset = 0,
		unsigned long	offset_high = 0,
		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.

Note

In win32 Each data block payload must be at least the size of a system memory page and must be aligned on a system memory page size boundary

Member Data Documentation

ACE_Asynch_Write_File_Impl* ACE_Asynch_Write_File::implementation_

protected

Implementation object.

---

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

• Asynch_IO.h
• Asynch_IO.cpp