ACE  6.2.2
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Pages
Classes | Public Member Functions | Protected Attributes | Private Member Functions | List of all members
ACE_Asynch_Read_Stream Class Reference

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

#include <Asynch_IO.h>

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

Classes

class  Result
 This is the class which will be passed back to the ACE_Handler::handle_read_stream when the asynchronous read completes. This class forwards all the methods to the implementation classes. More...
 

Public Member Functions

 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)
 
virtual ACE_Asynch_Operation_Implimplementation (void) const
 Return the underlying implementation class. More...
 
- 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_Stream_Implimplementation_
 Implementation class that all methods will be forwarded to. More...
 

Private Member Functions

void operator= (const ACE_Asynch_Read_Stream &)
 
 ACE_Asynch_Read_Stream (const ACE_Asynch_Read_Stream &)
 

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 stream. This class forwards all methods to its implementation class.

Once {open} is called, multiple asynchronous {read}s can started using this class. An ACE_Asynch_Read_Stream::Result will be passed back to the {handler} when the asynchronous reads completes through the {ACE_Handler::handle_read_stream} callback.

Constructor & Destructor Documentation

ACE_Asynch_Read_Stream::ACE_Asynch_Read_Stream ( void  )

A do nothing constructor.

ACE_Asynch_Read_Stream::~ACE_Asynch_Read_Stream ( void  )
virtual

Destructor.

ACE_Asynch_Read_Stream::ACE_Asynch_Read_Stream ( const ACE_Asynch_Read_Stream )
private

Member Function Documentation

ACE_Asynch_Operation_Impl * ACE_Asynch_Read_Stream::implementation ( void  ) const
virtual

Return the underlying implementation class.

Implements ACE_Asynch_Operation.

Reimplemented in ACE_Asynch_Read_File.

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

Parameters
handlerThe ACE_Handler that will be called to handle completions for operations initiated using this factory.
handleThe handle that future read operations will use. If handle == ACE_INVALID_HANDLE, ACE_Handler::handle() will be called on @ handler to get the correct handle.
Return values
0for success.
-1for failure; consult errno for further information.
void ACE_Asynch_Read_Stream::operator= ( const ACE_Asynch_Read_Stream )
private
int ACE_Asynch_Read_Stream::read ( ACE_Message_Block message_block,
size_t  num_bytes_to_read,
const void *  act = 0,
int  priority = 0,
int  signal_number = ACE_SIGRTMIN 
)

Initiate an asynchronous read operation.

Parameters
message_blockThe ACE_Message_Block to receive the data. Received bytes will be placed in the block beginning at its current write pointer. If data is read, the message block's write pointer will be advanced by the number of bytes read.
num_bytes_to_readThe maximum number of bytes to read.
actAsynchronous Completion Token; passed through to the completion handler in the Result object.
priorityPriority of the operation. 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 priority, etc. Ignored on Windows.
signal_numberThe POSIX4 real-time signal number to be used to signal completion of the operation. Values range from ACE_SIGRTMIN to ACE_SIGRTMAX. This argument is ignored on non-POSIX4 systems.
int ACE_Asynch_Read_Stream::readv ( ACE_Message_Block message_block,
size_t  num_bytes_to_read,
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.

Member Data Documentation

ACE_Asynch_Read_Stream_Impl* ACE_Asynch_Read_Stream::implementation_
protected

Implementation class that all methods will be forwarded to.


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