ACE  6.4.2
Classes | Public Member Functions | Protected Attributes | Private Member Functions | List of all members
ACE_Asynch_Read_File Class Reference

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

#include <Asynch_IO.h>

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

Classes

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

Public Member Functions

 ACE_Asynch_Read_File (void)
 A do nothing constructor. More...
 
virtual ~ACE_Asynch_Read_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 read (ACE_Message_Block &message_block, size_t bytes_to_read, unsigned long offset=0, unsigned long offset_high=0, const void *act=0, int priority=0, int signal_number=ACE_SIGRTMIN)
 
int readv (ACE_Message_Block &message_block, size_t bytes_to_read, 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_Implimplementation (void) const
 Return the underlying implementation class. More...
 
- Public Member Functions inherited from ACE_Asynch_Read_Stream
 ACE_Asynch_Read_Stream (void)
 A do nothing constructor. More...
 
virtual ~ACE_Asynch_Read_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 read (ACE_Message_Block &message_block, size_t num_bytes_to_read, const void *act=0, int priority=0, int signal_number=ACE_SIGRTMIN)
 
int readv (ACE_Message_Block &message_block, size_t num_bytes_to_read, 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_Proactorproactor (void) const
 Return the underlying proactor. More...
 
virtual ~ACE_Asynch_Operation (void)
 Destructor. More...
 

Protected Attributes

ACE_Asynch_Read_File_Implimplementation_
 
- Protected Attributes inherited from ACE_Asynch_Read_Stream
ACE_Asynch_Read_Stream_Implimplementation_
 Implementation class that all methods will be forwarded to. More...
 

Private Member Functions

void operator= (const ACE_Asynch_Read_File &)
 
 ACE_Asynch_Read_File (const ACE_Asynch_Read_File &)
 

Additional Inherited Members

- Protected Member Functions inherited from ACE_Asynch_Operation
 ACE_Asynch_Operation (void)
 Constructor. More...
 
ACE_Proactorget_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 reads on a file. This class forwards all methods to its implementation class.

Once open() is called, multiple asynchronous reads can started using this class. An ACE_Asynch_Read_File::Result will be passed back to the completion handler's ACE_Handler::handle_read_file() method when each asynchronous read completes. This class differs slightly from ACE_Asynch_Read_Stream as it allows the user to specify an offset for the read.

Constructor & Destructor Documentation

ACE_Asynch_Read_File::ACE_Asynch_Read_File ( void  )

A do nothing constructor.

ACE_Asynch_Read_File::~ACE_Asynch_Read_File ( void  )
virtual

Destructor.

ACE_Asynch_Read_File::ACE_Asynch_Read_File ( const ACE_Asynch_Read_File )
private

Member Function Documentation

ACE_Asynch_Operation_Impl * ACE_Asynch_Read_File::implementation ( void  ) const
virtual

Return the underlying implementation class.

Reimplemented from ACE_Asynch_Read_Stream.

int ACE_Asynch_Read_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 operation.

Parameters
handlerACE_Handler to be notified when operations initiated via this factory complete. The ACE_Handler::handle_read_file() method will be called on this object.
handleThe file handle to initiate read 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.
void ACE_Asynch_Read_File::operator= ( const ACE_Asynch_Read_File )
private
int ACE_Asynch_Read_File::read ( ACE_Message_Block message_block,
size_t  bytes_to_read,
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 read. Upto {bytes_to_read} will be read and stored in the {message_block}. The read will start at {offset} 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 argument 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_Read_File::readv ( ACE_Message_Block message_block,
size_t  bytes_to_read,
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 scatter 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_Read_File_Impl* ACE_Asynch_Read_File::implementation_
protected

Delegation/implementation class that all methods will be forwarded to.


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