Main Page | Namespace List | Class Hierarchy | Alphabetical List | Class List | File List | Namespace Members | Class Members | File Members | Related Pages | Search for 

ACE_POSIX_Asynch_Write_Dgram Class Reference

This class is a factory for starting off asynchronous writes on a UDP socket. The UDP socket must be "connected", as there is no facility for specifying the destination address on each send operation. More...

#include <POSIX_Asynch_IO.h>

Inheritance diagram for ACE_POSIX_Asynch_Write_Dgram:

Inheritance graph
[legend]
Collaboration diagram for ACE_POSIX_Asynch_Write_Dgram:

Collaboration graph
[legend]
List of all members.

Public Member Functions

 ACE_POSIX_Asynch_Write_Dgram (ACE_POSIX_Proactor *posix_proactor)
 Constructor.

virtual ~ACE_POSIX_Asynch_Write_Dgram (void)
 Destructor.

virtual ssize_t send (ACE_Message_Block *message_block, size_t &number_of_bytes_sent, int flags, const ACE_Addr &addr, const void *act, int priority, int signal_number)

Protected Member Functions

 ACE_POSIX_Asynch_Write_Dgram (void)
 Do-nothing constructor.

Detailed Description

This class is a factory for starting off asynchronous writes on a UDP socket. The UDP socket must be "connected", as there is no facility for specifying the destination address on each send operation.

Once open() is called, multiple asynchronous writes can started using this class. A ACE_Asynch_Write_Stream::Result will be passed back to the associated completion handler when the asynchronous write completes through the ACE_Handler::handle_write_stream() callback.

Definition at line 1176 of file POSIX_Asynch_IO.h.

Constructor & Destructor Documentation

ACE_POSIX_Asynch_Write_Dgram::ACE_POSIX_Asynch_Write_Dgram (  ACE_POSIX_Proactor *  posix_proactor  ) 
 

Constructor.

Definition at line 2409 of file POSIX_Asynch_IO.cpp. 

02410   : ACE_POSIX_Asynch_Operation (posix_proactor)
02411 {
02412 }

ACE_POSIX_Asynch_Write_Dgram::~ACE_POSIX_Asynch_Write_Dgram (  void   )  [virtual]
 

Destructor.

Definition at line 2366 of file POSIX_Asynch_IO.cpp. 

02367 {
02368 }

ACE_POSIX_Asynch_Write_Dgram::ACE_POSIX_Asynch_Write_Dgram (  void   )  [protected]
 

Do-nothing constructor.

Member Function Documentation

ssize_t ACE_POSIX_Asynch_Write_Dgram::send (  ACE_Message_Block *  message_block,
size_t &  number_of_bytes_sent,
int  flags,
const ACE_Addr &  addr,
const void *  act,
int  priority,
int  signal_number
)  [virtual]
 

This method queues an asynchronous send. Up to message_block->total_length bytes will be sent, beginning at the read pointer. The message_block read pointer will be updated to reflect the sent bytes if the send operation is successful completed.

Priority of the operation is specified by priority. On POSIX, 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, etc. signal_number is a no-op on non-POSIX4 systems.

Note:
Unlike the Windows version of this facility, no indication of immediate success can be returned, and number_of_bytes_sent is never used.
  • flags Not used.
  • addr Not used.
    Return values:
    0 The IO will complete asynchronously.
    -1 There was an error; see errno to get the error code.

Implements ACE_Asynch_Write_Dgram_Impl.

Definition at line 2371 of file POSIX_Asynch_IO.cpp.

References ACE_ERROR_RETURN, ACE_LIB_TEXT, ACE_NEW_RETURN, ACE_POSIX_Proactor::get_handle(), ACE_Message_Block::length(), LM_ERROR, ACE_POSIX_Asynch_Operation::posix_proactor(), and ACE_POSIX_Proactor::start_aio(). 

02378 {
02379   size_t len = message_block->length ();
02380   if (len == 0)
02381     ACE_ERROR_RETURN
02382       ((LM_ERROR,
02383         ACE_LIB_TEXT ("ACE_POSIX_Asynch_Write_Stream::write:")
02384         ACE_LIB_TEXT ("Attempt to write 0 bytes\n")),
02385       -1);
02386 
02387   ACE_POSIX_Asynch_Write_Dgram_Result *result = 0;
02388   ACE_POSIX_Proactor *proactor = this->posix_proactor ();
02389   ACE_NEW_RETURN (result,
02390                   ACE_POSIX_Asynch_Write_Dgram_Result (this->handler_proxy_,
02391                                                        this->handle_,
02392                                                        message_block,
02393                                                        len,
02394                                                        flags,
02395                                                        act,
02396                                                        proactor->get_handle (),
02397                                                        priority,
02398                                                        signal_number),
02399                   -1);
02400 
02401   int return_val = proactor->start_aio (result, ACE_POSIX_Proactor::ACE_OPCODE_WRITE);
02402   if (return_val == -1)
02403     delete result;
02404 
02405   return return_val;
02406 }

The documentation for this class was generated from the following files:
Generated on Thu Nov 9 11:26:55 2006 for ACE by doxygen 1.3.6