Main Page   Namespace List   Class Hierarchy   Alphabetical List   Compound List   File List   Namespace Members   Compound Members   File Members   Related Pages  

TAO_Synch_Queued_Message Class Reference

Specialize TAO_Queued_Message for synchronous requests, i.e. twoways and oneways sent with reliability better than SYNC_NONE. More...

#include <Synch_Queued_Message.h>

Inheritance diagram for TAO_Synch_Queued_Message:

Inheritance graph
[legend]
Collaboration diagram for TAO_Synch_Queued_Message:

Collaboration graph
[legend]
List of all members.

Public Methods

 TAO_Synch_Queued_Message (const ACE_Message_Block *contents, ACE_Allocator *alloc=0, int is_heap_allocated=0)
 Constructor. More...

virtual ~TAO_Synch_Queued_Message (void)
 Destructor. More...

const ACE_Message_Blockcurrent_block (void) const
virtual size_t message_length (void) const
virtual int all_data_sent (void) const
virtual void fill_iov (int iovcnt_max, int &iovcnt, iovec iov[]) const
virtual void bytes_transferred (size_t &byte_count)
virtual TAO_Queued_Messageclone (ACE_Allocator *alloc)
virtual void destroy (void)

Private Attributes

ACE_Message_Blockcontents_
 The contents of the message. More...

ACE_Message_Blockcurrent_block_
 The current message block. More...


Detailed Description

Specialize TAO_Queued_Message for synchronous requests, i.e. twoways and oneways sent with reliability better than SYNC_NONE.

Reliable requests block the sending thread until the message is sent, likewise, the sending thread must be informed if the connection is closed or the message times out.

In contrast oneway (and AMI) requests sent with the SYNC_NONE policy are simple discarded if the connection fails or they timeout.

Another important difference is the management of the data buffer: one SYNC_NONE messages the buffer is immediately copied into a newly allocated buffer, and must be deallocated. Other types of requests use the memory allocated by the sending thread.

Definition at line 44 of file Synch_Queued_Message.h.


Constructor & Destructor Documentation

TAO_Synch_Queued_Message::TAO_Synch_Queued_Message const ACE_Message_Block   contents,
ACE_Allocator   alloc = 0,
int    is_heap_allocated = 0
 

Constructor.

Parameters:
contents  The message block chain that must be sent.
alloc  The allocator that is used to allocate objects of this type.

Definition at line 14 of file Synch_Queued_Message.cpp.

Referenced by clone.

00017   : TAO_Queued_Message (alloc, is_heap_allocated)
00018   , contents_ (ACE_const_cast (ACE_Message_Block*,contents))
00019   , current_block_ (contents_)
00020 {
00021 }

TAO_Synch_Queued_Message::~TAO_Synch_Queued_Message void    [virtual]
 

Destructor.

Definition at line 23 of file Synch_Queued_Message.cpp.

00024 {
00025 
00026 }


Member Function Documentation

int TAO_Synch_Queued_Message::all_data_sent void    const [virtual]
 

Implement the Template Methods from TAO_Queued_Message

Implements TAO_Queued_Message.

Definition at line 43 of file Synch_Queued_Message.cpp.

References current_block_.

Referenced by TAO_Transport::send_message_block_chain_i, TAO_Transport::send_synch_message_helper_i, and TAO_Transport::send_synchronous_message_i.

00044 {
00045   return this->current_block_ == 0;
00046 }

void TAO_Synch_Queued_Message::bytes_transferred size_t &    byte_count [virtual]
 

Implement the Template Methods from TAO_Queued_Message

Implements TAO_Queued_Message.

Definition at line 75 of file Synch_Queued_Message.cpp.

References ACE_Message_Block::cont, current_block_, ACE_Message_Block::length, TAO_LF_Event::LFS_ACTIVE, TAO_LF_Event::LFS_SUCCESS, ACE_Message_Block::rd_ptr, TAO_LF_Event::state_changed, and TAO_LF_Invocation_Event::state_changed_i.

00076 {
00077   this->state_changed_i (TAO_LF_Event::LFS_ACTIVE);
00078 
00079   while (this->current_block_ != 0 && byte_count > 0)
00080     {
00081       size_t l = this->current_block_->length ();
00082 
00083       if (byte_count < l)
00084         {
00085           this->current_block_->rd_ptr (byte_count);
00086           byte_count = 0;
00087           return;
00088         }
00089       byte_count -= l;
00090       this->current_block_->rd_ptr (l);
00091       this->current_block_ = this->current_block_->cont ();
00092       while (this->current_block_ != 0
00093              && this->current_block_->length () == 0)
00094         {
00095           this->current_block_ = this->current_block_->cont ();
00096         }
00097     }
00098   if (this->current_block_ == 0)
00099     this->state_changed (TAO_LF_Event::LFS_SUCCESS);
00100 }

TAO_Queued_Message * TAO_Synch_Queued_Message::clone ACE_Allocator   alloc [virtual]
 

Implement the Template Methods from TAO_Queued_Message

Implements TAO_Queued_Message.

Definition at line 103 of file Synch_Queued_Message.cpp.

References ACE_DEBUG, ACE_NEW_MALLOC_RETURN, ACE_NEW_RETURN, ACE_Message_Block::clone, current_block_, TAO_Queued_Message::is_heap_created_, LM_DEBUG, ACE_Allocator::malloc, and TAO_Synch_Queued_Message.

Referenced by TAO_Transport::send_reply_message_i.

00104 {
00105   TAO_Synch_Queued_Message *qm = 0;
00106 
00107   // Clone the message block.
00108   // NOTE: We wantedly do the cloning from <current_block_> instead of
00109   // starting from <contents_> since we dont want to clone blocks that
00110   // have already been sent on the wire. Waste of memory and
00111   // associated copying.
00112   ACE_Message_Block *mb =
00113     this->current_block_->clone ();
00114 
00115   if (alloc)
00116     {
00117       ACE_NEW_MALLOC_RETURN (qm,
00118                              ACE_static_cast (TAO_Synch_Queued_Message *,
00119                                  alloc->malloc (sizeof (TAO_Synch_Queued_Message))),
00120                              TAO_Synch_Queued_Message (mb,
00121                                                        alloc),
00122                              0);
00123     }
00124   else
00125     {
00126       // No allocator, so use the common heap!
00127       if (TAO_debug_level == 4)
00128         {
00129           // This debug is for testing purposes!
00130           ACE_DEBUG ((LM_DEBUG,
00131                       "TAO (%P|%t) - Synch_Queued_Message::clone\n",
00132                       "Using global pool for allocation \n"));
00133         }
00134 
00135       ACE_NEW_RETURN (qm,
00136                       TAO_Synch_Queued_Message (mb),
00137                       0);
00138     }
00139 
00140   // Set the flag to indicate that <qm> is created on the heap.
00141   if (qm)
00142     qm->is_heap_created_ = 1;
00143 
00144   return qm;
00145 }

const ACE_Message_Block * TAO_Synch_Queued_Message::current_block void    const
 

Definition at line 29 of file Synch_Queued_Message.cpp.

References current_block_.

Referenced by TAO_Transport::send_synchronous_message_i.

00030 {
00031   return this->current_block_;
00032 }

void TAO_Synch_Queued_Message::destroy void    [virtual]
 

Implement the Template Methods from TAO_Queued_Message

Implements TAO_Queued_Message.

Definition at line 148 of file Synch_Queued_Message.cpp.

References ACE_DES_FREE, TAO_Queued_Message::allocator_, current_block_, TAO_Queued_Message::is_heap_created_, and ACE_Message_Block::release.

00149 {
00150   if (this->is_heap_created_)
00151     {
00152       ACE_Message_Block::release (this->contents_);
00153       this->current_block_ = 0;
00154 
00155       // If we have an allocator release the memory to the allocator
00156       // pool.
00157       if (this->allocator_)
00158         {
00159           ACE_DES_FREE (this,
00160                         this->allocator_->free,
00161                         TAO_Synch_Queued_Message);
00162 
00163         }
00164       else // global release..
00165         {
00166           delete this;
00167         }
00168     }
00169 }

void TAO_Synch_Queued_Message::fill_iov int    iovcnt_max,
int &    iovcnt,
iovec    iov[]
const [virtual]
 

Implement the Template Methods from TAO_Queued_Message

Implements TAO_Queued_Message.

Definition at line 49 of file Synch_Queued_Message.cpp.

References ACE_ASSERT, ACE_Message_Block::cont, current_block_, iovec::iov_base, iovec::iov_len, ACE_Message_Block::length, and ACE_Message_Block::rd_ptr.

00052 {
00053   ACE_ASSERT (iovcnt_max > iovcnt);
00054 
00055   for (const ACE_Message_Block *message_block = this->current_block_;
00056        message_block != 0 && iovcnt < iovcnt_max;
00057        message_block = message_block->cont ())
00058     {
00059       size_t message_block_length = message_block->length ();
00060 
00061       // Check if this block has any data to be sent.
00062       if (message_block_length > 0)
00063         {
00064               // Collect the data in the iovec.
00065           iov[iovcnt].iov_base = message_block->rd_ptr ();
00066           iov[iovcnt].iov_len  = ACE_static_cast(u_long, message_block_length);
00067 
00068           // Increment iovec counter.
00069           iovcnt++;
00070         }
00071     }
00072 }

size_t TAO_Synch_Queued_Message::message_length void    const [virtual]
 

Implement the Template Methods from TAO_Queued_Message

Implements TAO_Queued_Message.

Definition at line 35 of file Synch_Queued_Message.cpp.

References current_block_, and ACE_Message_Block::total_length.

Referenced by TAO_Transport::send_message_block_chain_i.

00036 {
00037   if (this->current_block_ == 0)
00038     return 0;
00039   return this->current_block_->total_length ();
00040 }


Member Data Documentation

ACE_Message_Block* TAO_Synch_Queued_Message::contents_ [private]
 

The contents of the message.

The message is normally generated by a TAO_OutputCDR stream. The application marshals the payload, possibly generating a chain of message block connected via the 'cont()' field.

Definition at line 81 of file Synch_Queued_Message.h.

ACE_Message_Block* TAO_Synch_Queued_Message::current_block_ [private]
 

The current message block.

The message may be set in multiple writev() operations. This point keeps track of the next message to send out.

Definition at line 88 of file Synch_Queued_Message.h.

Referenced by all_data_sent, bytes_transferred, clone, current_block, destroy, fill_iov, and message_length.


The documentation for this class was generated from the following files:
Generated on Mon Jun 16 15:40:58 2003 for TAO by doxygen1.2.14 written by Dimitri van Heesch, © 1997-2002