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

TAO_Queued_Data Class Reference

Represents a node in the queue of incoming messages. More...

#include <Incoming_Message_Queue.h>

Collaboration diagram for TAO_Queued_Data:

Collaboration graph
[legend]
List of all members.

Missing Data details

The missing_data_bytes_ member contains the number of bytes of data missing from msg_block_. However, there can be two places where data is missing: header and payload. We cannot know how much data is missing from the payload until we have a complete header. Fortunately, headers are a fixed length, so we can know how much we're missing from the header.

We use

Parameters:
current_state_  to indicate which portion of the message
missing_data_bytes_  refers to, as well as the general state of the message.


enum  Queued_Data_State { INVALID = -1, COMPLETED = 0, WAITING_TO_COMPLETE_HEADER, WAITING_TO_COMPLETE_PAYLOAD }
Queued_Data_State current_state_
size_t missing_data_bytes_

Factory Methods

These methods manufacture instances of TAO_Queued_Data and return them. These instances should be removed via TAO_Queued_Data::release.

Instances are initialized from data in the ACE_Message_Block, interpreted according to rules defined in the TAO_Pluggable_Messaging object.

The manufactured instance adopts the message block without duplicating it; therefore, the caller must duplicate or orphan the message block. The caller also must insure that the message block can be released via ACE_Message_Block::release, and that its life endures beyond the calling scope.

For the purposes of TAO_Queued_Data, a completed message is a completely received message as defined by the messaging protocol object. For GIOP, that means that the number of bytes specified in the general GIOP header have been completely received. It specifically DOES NOT mean that all fragments have been received. Fragment reassembly is another matter altogether.

void consolidate (void)
 Consolidate this fragments chained message blocks into one. More...

TAO_Queued_Data * make_uncompleted_message (ACE_Message_Block *mb, TAO_Pluggable_Messaging &msging_obj, ACE_Allocator *alloc=0)
 Make and return an instance of TAO_Queued_Data suitable for use as an uncompleted message. More...

TAO_Queued_Data * make_completed_message (ACE_Message_Block &mb, TAO_Pluggable_Messaging &msging_obj, ACE_Allocator *alloc=0)
 Make and return an instance of TAO_Queued_Data suitable for use as a completed message. More...

TAO_Queued_Data * make_queued_data (ACE_Allocator *alloc=0)
 Creation and deletion of a node in the queue. More...


Public Types


Public Methods

 TAO_Queued_Data (const TAO_Queued_Data &qd)
 Copy constructor. More...

void release (void)

Static Public Methods

void release (TAO_Queued_Data *qd)
TAO_Queued_Data * duplicate (TAO_Queued_Data &qd)
 Duplicate ourselves. This creates a copy of ourselves on the heap and returns a pointer to the duplicated node. More...


Public Attributes

ACE_Message_Blockmsg_block_
 The message block that contains the message. More...

CORBA::Octet byte_order_
CORBA::Octet major_version_
 Many protocols like GIOP have a major and minor version information that would be needed to read and decipher the message. More...

CORBA::Octet minor_version_
CORBA::Octet more_fragments_
 Some messages can be fragmented by the protocol (this is an ORB level fragmentation on top of the TCP/IP fragmentation. This member indicates whether the message that we have recd. and queue already has more fragments that is missing.. More...

CORBA::ULong request_id_
 The fragment request id. More...

TAO_Pluggable_Message_Type msg_type_
 The message type of the message. More...

TAO_Queued_Data * next_
 Pounter to the next element in the queue. More...


Protected Methods

 TAO_Queued_Data (ACE_Allocator *alloc=0)
 Default Constructor. More...

 TAO_Queued_Data (ACE_Message_Block *mb, ACE_Allocator *alloc=0)
 Constructor. More...


Static Private Methods

void replace_data_block (ACE_Message_Block &mb)
 Replace the datablock with a one allocated on the heap or allocator. More...


Private Attributes

ACE_Allocatorallocator_
 The allocator used to allocate this class. More...


Detailed Description

Represents a node in the queue of incoming messages.

This class contains necessary information about a message that is stored in the queue. Such a node can be used by the incoming thread from the reactor to dequeue and process the message by sending it to the higher layers of the ORB.

Definition at line 160 of file Incoming_Message_Queue.h.


Member Enumeration Documentation

enum TAO_Queued_Data::Queued_Data_State
 

Describes the meaning given to the number stored in missing_data_bytes_.

Enumeration values:
INVALID  The queued data is in an invalid/uninitialized state, and no data should be trusted.
COMPLETED  Message is complete; missing_data_bytes_ should be zero.
WAITING_TO_COMPLETE_HEADER  Value in missing_data_bytes_ indicates part of header is missing.
WAITING_TO_COMPLETE_PAYLOAD  Value in missing_data_bytes_ indicates part of payload is missing.

Definition at line 256 of file Incoming_Message_Queue.h.

00257   {
00258     INVALID = -1,               //!< The queued data is in an invalid/uninitialized state, and no data should be trusted.
00259     COMPLETED = 0,              //!< Message is complete; \a missing_data_bytes_ should be zero.
00260     WAITING_TO_COMPLETE_HEADER, //!< Value in \a missing_data_bytes_ indicates part of header is missing.
00261     WAITING_TO_COMPLETE_PAYLOAD //!< Value in \a missing_data_bytes_ indicates part of payload is missing.
00262   };


Constructor & Destructor Documentation

TAO_Queued_Data::TAO_Queued_Data ACE_Allocator   alloc = 0 [protected]
 

Default Constructor.

Definition at line 187 of file Incoming_Message_Queue.cpp.

References TAO_PLUGGABLE_MESSAGE_MESSAGERROR.

Referenced by duplicate, and make_queued_data.

00188   : msg_block_ (0)
00189   , current_state_ (INVALID)
00190   , missing_data_bytes_ (0)
00191   , byte_order_ (0)
00192   , major_version_ (0)
00193   , minor_version_ (0)
00194   , more_fragments_ (0)
00195   , request_id_ (0)
00196   , msg_type_ (TAO_PLUGGABLE_MESSAGE_MESSAGERROR)
00197   , next_ (0)
00198   , allocator_ (alloc)
00199 {
00200 }

TAO_Queued_Data::TAO_Queued_Data ACE_Message_Block   mb,
ACE_Allocator   alloc = 0
[protected]
 

Constructor.

Definition at line 202 of file Incoming_Message_Queue.cpp.

References TAO_PLUGGABLE_MESSAGE_MESSAGERROR.

00204   : msg_block_ (mb)
00205   , current_state_ (INVALID)
00206   , missing_data_bytes_ (0)
00207   , byte_order_ (0)
00208   , major_version_ (0)
00209   , minor_version_ (0)
00210   , more_fragments_ (0)
00211   , request_id_ (0)
00212   , msg_type_ (TAO_PLUGGABLE_MESSAGE_MESSAGERROR)
00213   , next_ (0)
00214   , allocator_ (alloc)
00215 {
00216 }

TAO_Queued_Data::TAO_Queued_Data const TAO_Queued_Data &    qd
 

Copy constructor.

Definition at line 218 of file Incoming_Message_Queue.cpp.

00219   : msg_block_ (qd.msg_block_->duplicate ())
00220   , current_state_ (qd.current_state_)
00221   , missing_data_bytes_ (qd.missing_data_bytes_)
00222   , byte_order_ (qd.byte_order_)
00223   , major_version_ (qd.major_version_)
00224   , minor_version_ (qd.minor_version_)
00225   , more_fragments_ (qd.more_fragments_)
00226   , request_id_ (qd.request_id_)
00227   , msg_type_ (qd.msg_type_)
00228   , next_ (0)
00229   , allocator_ (qd.allocator_)
00230 {
00231 }


Member Function Documentation

void TAO_Queued_Data::consolidate void   
 

Consolidate this fragments chained message blocks into one.

Definition at line 605 of file Incoming_Message_Queue.cpp.

References clone_mb_nocopy_size, ACE_CDR::consolidate, ACE_Message_Block::cont, more_fragments_, msg_block_, and ACE_Message_Block::release.

Referenced by TAO_Transport::enqueue_incoming_message.

00606 {
00607   // Is this a chain of fragments?
00608   if (this->more_fragments_ && this->msg_block_->cont () != 0)
00609     {
00610       // Create a message block big enough to hold the entire chain
00611       ACE_Message_Block *dest = clone_mb_nocopy_size (
00612                                       this->msg_block_,
00613                                       this->msg_block_->total_length ());
00614       // Reset the cont() parameter
00615       dest->cont (0);
00616 
00617       // Use ACE_CDR to consolidate the chain for us
00618       ACE_CDR::consolidate (dest, this->msg_block_);
00619 
00620       // free the original message block chain
00621       this->msg_block_->release ();
00622 
00623       // Set the message block to the new consolidated message block
00624       this->msg_block_ = dest;
00625       this->more_fragments_ = 0;
00626     }
00627 }

TAO_Queued_Data * TAO_Queued_Data::duplicate TAO_Queued_Data &    qd [static]
 

Duplicate ourselves. This creates a copy of ourselves on the heap and returns a pointer to the duplicated node.

Definition at line 558 of file Incoming_Message_Queue.cpp.

References ACE_BIT_ENABLED, ACE_DEBUG, ACE_NEW_MALLOC_RETURN, ACE_NEW_RETURN, allocator_, ACE_Message_Block::DONT_DELETE, LM_DEBUG, ACE_Allocator::malloc, ACE_Message_Block::Message_Flags, msg_block_, replace_data_block, ACE_Message_Block::self_flags, and TAO_Queued_Data.

00559 {
00560   // Check to see if the underlying block is on the stack. If not it
00561   // is fine. If the datablock is on stack, try to make a copy of that
00562   // before doing a duplicate.
00563   // @@ todo: Theoretically this should be within the Message Block,
00564   // but we dont have much scope to do this in that mess. Probably in
00565   // the next stage of MB rewrite we should be okay
00566   ACE_Message_Block::Message_Flags fl =
00567     sqd.msg_block_->self_flags ();
00568 
00569   if (ACE_BIT_ENABLED (fl,
00570                        ACE_Message_Block::DONT_DELETE))
00571     (void) TAO_Queued_Data::replace_data_block (*sqd.msg_block_);
00572 
00573 
00574   TAO_Queued_Data *qd = 0;
00575 
00576   if (sqd.allocator_)
00577     {
00578       ACE_NEW_MALLOC_RETURN (qd,
00579                              ACE_static_cast(TAO_Queued_Data *,
00580                                sqd.allocator_->malloc (sizeof (TAO_Queued_Data))),
00581                              TAO_Queued_Data (sqd),
00582                             0);
00583 
00584       return qd;
00585     }
00586 
00587   // No allocator, so use the global pool!
00588   // @@ TODO: We should be removing this at some point of time!
00589   if (TAO_debug_level == 4)
00590     {
00591       // This debug is for testing purposes!
00592       ACE_DEBUG ((LM_DEBUG,
00593                   "TAO (%P|%t) - Queued_Data[%d]::duplicate\n",
00594                   "Using global pool for allocation \n"));
00595     }
00596 
00597   ACE_NEW_RETURN (qd,
00598                   TAO_Queued_Data (sqd),
00599                   0);
00600 
00601   return qd;
00602 }

TAO_Queued_Data * TAO_Queued_Data::make_completed_message ACE_Message_Block   mb,
TAO_Pluggable_Messaging   msging_obj,
ACE_Allocator   alloc = 0
[static]
 

Make and return an instance of TAO_Queued_Data suitable for use as a completed message.

Definition at line 421 of file Incoming_Message_Queue.cpp.

References ACE_DEBUG, ACE_HEX_DUMP, ACE_TEXT, clone_mb_nocopy_size, COMPLETED, copy_mb_span, current_state_, INVALID, ACE_Message_Block::length, LM_DEBUG, make_queued_data, missing_data_bytes_, msg_block_, ACE_Message_Block::rd_ptr, release, and WAITING_TO_COMPLETE_PAYLOAD.

Referenced by TAO_Transport::handle_input_i.

00424 {
00425   register const size_t HDR_LEN = msging_obj.header_length ();
00426   register const size_t MB_LEN  = mb.length ();
00427 
00428   // Validate arguments.
00429   if (MB_LEN < HDR_LEN)
00430     return 0;
00431 
00432   size_t total_msg_len = 0;
00433   register TAO_Queued_Data *new_qd = make_queued_data (alloc);
00434   if (new_qd == 0)
00435     goto failure;
00436 
00437   // We can assume that there are enough bytes for a header, so
00438   // extract the header data.  Don't assume that there's enough for
00439   // the payload just yet.
00440   new_qd->current_state_ = WAITING_TO_COMPLETE_PAYLOAD;
00441   msging_obj.set_queued_data_from_message_header (new_qd, mb);
00442   if (new_qd->current_state_ == INVALID)
00443     goto failure;
00444 
00445   // new_qd_->missing_data_bytes_ + protocol header length should be
00446   // *at least* the length of the message.  Verify that we have that
00447   // many bytes in the message block and, if we don't, release the new
00448   // qd and fail.
00449   total_msg_len = new_qd->missing_data_bytes_ + HDR_LEN;
00450   if (total_msg_len > MB_LEN)
00451     goto failure;
00452 
00453   // Make a copy of the relevant portion of mb and hang on to it
00454   if ((new_qd->msg_block_ = clone_mb_nocopy_size (&mb, total_msg_len)) == 0)
00455     goto failure;
00456 
00457   if (copy_mb_span (new_qd->msg_block_, &mb, total_msg_len) == 0)
00458     goto failure;
00459   
00460   // Update missing data and the current state
00461   new_qd->missing_data_bytes_ = 0;
00462   new_qd->current_state_ = COMPLETED;
00463 
00464   // Advance the rd_ptr on the message block
00465   mb.rd_ptr (total_msg_len);
00466 
00467   if (TAO_debug_level > 7)
00468     {
00469       ACE_DEBUG ((LM_DEBUG,
00470                   ACE_TEXT ("TAO (%P|%t) Queued_Data::make_complete_message: ")
00471                   ACE_TEXT ("extracted complete message (%u bytes incl hdr) from mblk=%-08x into qd=%-08x\n"),
00472                   total_msg_len, &mb, new_qd));
00473     }
00474 
00475   return new_qd;
00476 
00477 failure:
00478   if (TAO_debug_level > 7)
00479     {
00480       ACE_DEBUG ((LM_DEBUG,
00481                   ACE_TEXT ("TAO (%P|%t) Queued_Data::make_complete_message: ")
00482                   ACE_TEXT ("failed to find complete message in mblk=%-08x; leaving %u bytes in block\n"),
00483                   &mb, MB_LEN));
00484       if (TAO_debug_level >= 10)
00485         ACE_HEX_DUMP ((LM_DEBUG,
00486                        mb.rd_ptr (), MB_LEN,
00487                        ACE_TEXT ("                residual bytes in buffer")));
00488 
00489     }
00490   TAO_Queued_Data::release (new_qd);
00491   return 0;
00492 }

TAO_Queued_Data * TAO_Queued_Data::make_queued_data ACE_Allocator   alloc = 0 [static, private]
 

Creation and deletion of a node in the queue.

Todo:
Maybe this should be private?

Definition at line 496 of file Incoming_Message_Queue.cpp.

References ACE_DEBUG, ACE_NEW_MALLOC_RETURN, ACE_NEW_RETURN, LM_DEBUG, ACE_Allocator::malloc, and TAO_Queued_Data.

Referenced by make_completed_message, and make_uncompleted_message.

00497 {
00498   TAO_Queued_Data *qd = 0;
00499 
00500   if (alloc)
00501     {
00502       ACE_NEW_MALLOC_RETURN (qd,
00503                             ACE_static_cast (TAO_Queued_Data *,
00504                               alloc->malloc (sizeof (TAO_Queued_Data))),
00505                             TAO_Queued_Data (alloc),
00506                             0);
00507 
00508       return qd;
00509     }
00510 
00511   // No allocator, so use the global pool!
00512   // @@ TODO: We should be removing this at some point of time!
00513   if (TAO_debug_level == 4)
00514     {
00515       // This debug is for testing purposes!
00516       ACE_DEBUG ((LM_DEBUG,
00517                   "TAO (%P|%t) - Queued_Data::get_queued_data\n",
00518                   "Using global pool for allocation \n"));
00519     }
00520 
00521   ACE_NEW_RETURN (qd,
00522                   TAO_Queued_Data,
00523                   0);
00524 
00525   return qd;
00526 }

TAO_Queued_Data * TAO_Queued_Data::make_uncompleted_message ACE_Message_Block   mb,
TAO_Pluggable_Messaging   msging_obj,
ACE_Allocator   alloc = 0
[static]
 

Make and return an instance of TAO_Queued_Data suitable for use as an uncompleted message.

Definition at line 324 of file Incoming_Message_Queue.cpp.

References ACE_ASSERT, ACE_DEBUG, ACE_TEXT, clone_mb_nocopy_size, COMPLETED, copy_mb_span, current_state_, INVALID, ACE_Message_Block::length, LM_DEBUG, make_queued_data, missing_data_bytes_, msg_block_, ACE_Message_Block::rd_ptr, release, WAITING_TO_COMPLETE_HEADER, and WAITING_TO_COMPLETE_PAYLOAD.

Referenced by TAO_Transport::handle_input_i.

00327 {
00328   register TAO_Queued_Data *new_qd = 0;
00329   register const size_t HDR_LEN = msging_obj.header_length (); /* COMPUTE ONCE! */
00330   register const size_t MB_LEN = mb->length (); /* COMPUTE ONCE! */
00331 
00332   // Validate arguments.
00333   if (mb == 0)
00334     goto failure;
00335 
00336   new_qd = make_queued_data (alloc);
00337   if (new_qd == 0)
00338     goto failure;
00339 
00340   // do we have enough bytes to make a complete header?
00341   if (MB_LEN >= HDR_LEN)
00342     {
00343       // Since we have enough bytes to make a complete header,
00344       // the header needs to be valid.  Check that now, and punt
00345       // if it's not valid.
00346       if (! msging_obj.check_for_valid_header (*mb))
00347         {
00348           goto failure;
00349         }
00350       else
00351         {
00352           new_qd->current_state_ = WAITING_TO_COMPLETE_PAYLOAD;
00353           msging_obj.set_queued_data_from_message_header (new_qd, *mb);
00354 
00355           // missing_data_bytes_ now has the full GIOP message size, so we allocate
00356           // a new message block of that size, plus the header.
00357           new_qd->msg_block_ = clone_mb_nocopy_size  (mb,
00358                                                       new_qd->missing_data_bytes_ +
00359                                                       HDR_LEN);
00360           // Of course, we don't have the whole message (if we did, we
00361           // wouldn't be here!), so we copy only what we've got, i.e., whatever's
00362           // in the message block.
00363           if (copy_mb_span (new_qd->msg_block_, mb, MB_LEN) == 0)
00364             goto failure;
00365 
00366           // missing_data_bytes_ now has the full GIOP message size, but
00367           // there might still be stuff in mb.  Therefore, we have to adjust
00368           // missing_data_bytes_, i.e., decrease it by the number of "actual
00369           // payload bytes" in mb.
00370           //
00371           // "actual payload bytes" :== length of mb (which included the header) - header length
00372           new_qd->missing_data_bytes_ -= (MB_LEN - HDR_LEN);
00373           mb->rd_ptr (MB_LEN);
00374         }
00375     }
00376   else
00377     {
00378       new_qd->current_state_ = WAITING_TO_COMPLETE_HEADER;
00379       new_qd->msg_block_ = clone_mb_nocopy_size (mb, HDR_LEN);
00380       if (new_qd->msg_block_ == 0 ||
00381           copy_mb_span (new_qd->msg_block_, mb, MB_LEN) == 0)
00382         goto failure;
00383       new_qd->missing_data_bytes_ = HDR_LEN - MB_LEN;
00384       mb->rd_ptr (MB_LEN);
00385     }
00386 
00387   ACE_ASSERT (new_qd->current_state_ != INVALID);
00388   if (TAO_debug_level > 7)
00389     {
00390       const char* s = "?unk?";
00391       switch (new_qd->current_state_)
00392         {
00393         case WAITING_TO_COMPLETE_HEADER: s = "WAITING_TO_COMPLETE_HEADER"; break;
00394         case WAITING_TO_COMPLETE_PAYLOAD: s = "WAITING_TO_COMPLETE_PAYLOAD"; break;
00395         case INVALID: s = "INVALID"; break;
00396         case COMPLETED: s = "COMPLETED"; break;
00397         }
00398       ACE_DEBUG ((LM_DEBUG,
00399                   ACE_TEXT ("TAO (%P|%t) Queued_Data::make_uncompleted_message: ")
00400                   ACE_TEXT ("made uncompleted message from %u bytes into qd=%-08x:")
00401                   ACE_TEXT ("state=%s,missing_data_bytes=%u\n"),
00402                   new_qd->msg_block_->length(), new_qd, s, new_qd->missing_data_bytes_));
00403     }
00404   return new_qd;
00405 
00406 failure:
00407   if (TAO_debug_level > 7)
00408     {
00409       ACE_DEBUG ((LM_DEBUG,
00410                   ACE_TEXT ("TAO (%P|%t) Queued_Data::make_uncompleted_message: ")
00411                   ACE_TEXT ("failed to make uncompleted message: mb=%-08x, qd=%-08x\n"),
00412                   mb, new_qd));
00413     }
00414   TAO_Queued_Data::release (new_qd);
00415   return 0;
00416 }

ACE_INLINE void TAO_Queued_Data::release void   
 

Definition at line 69 of file Incoming_Message_Queue.inl.

Referenced by make_completed_message, make_uncompleted_message, TAO_Transport::process_queue_head, and TAO_Incoming_Message_Queue::~TAO_Incoming_Message_Queue.

00070 {
00071   TAO_Queued_Data::release (this);
00072 }

void TAO_Queued_Data::release TAO_Queued_Data *    qd [static]
 

Definition at line 530 of file Incoming_Message_Queue.cpp.

References ACE_DEBUG, ACE_DES_FREE, allocator_, ACE_Allocator::free, LM_DEBUG, msg_block_, and ACE_Message_Block::release.

Referenced by TAO_Transport::enqueue_incoming_message.

00531 {
00532   //// TODO
00533   ACE_Message_Block::release (qd->msg_block_);
00534 
00535   if (qd->allocator_)
00536     {
00537       ACE_DES_FREE (qd,
00538                     qd->allocator_->free,
00539                     TAO_Queued_Data);
00540 
00541       return;
00542     }
00543 
00544   // @@todo: Need to be removed at some point of time!
00545   if (TAO_debug_level == 4)
00546     {
00547       // This debug is for testing purposes!
00548       ACE_DEBUG ((LM_DEBUG,
00549                   "TAO (%P|%t) - Queued_Data[%d]::release\n",
00550                   "Using global pool for releasing \n"));
00551     }
00552   delete qd;
00553 
00554 }

ACE_INLINE void TAO_Queued_Data::replace_data_block ACE_Message_Block   mb [static, private]
 

Replace the datablock with a one allocated on the heap or allocator.

Definition at line 76 of file Incoming_Message_Queue.inl.

References ACE_Data_Block::clone_nocopy, ACE_Message_Block::clr_self_flags, ACE_Message_Block::copy, ACE_Message_Block::data_block, ACE_Message_Block::DONT_DELETE, ACE_Data_Block::duplicate, ACE_Message_Block::length, ACE_CDR::MAX_ALIGNMENT, ACE_CDR::mb_align, ACE_Message_Block::rd_ptr, ACE_Data_Block::size, ACE_CDR::total_length, and ACE_Message_Block::wr_ptr.

Referenced by duplicate.

00077 {
00078   size_t newsize =
00079     ACE_CDR::total_length (&mb, 0) + ACE_CDR::MAX_ALIGNMENT;
00080 
00081   ACE_Data_Block *db =
00082     mb.data_block ()->clone_nocopy ();
00083 
00084   if (db->size (newsize) == -1)
00085     return;
00086 
00087   ACE_Message_Block tmp (db);
00088   ACE_CDR::mb_align (&tmp);
00089 
00090   tmp.copy (mb.rd_ptr (), mb.length());
00091   mb.data_block (tmp.data_block ()->duplicate ());
00092 
00093   mb.rd_ptr (tmp.rd_ptr ());
00094   mb.wr_ptr (tmp.wr_ptr ());
00095 
00096   // Remove the DONT_DELETE flags from mb
00097   mb.clr_self_flags (ACE_Message_Block::DONT_DELETE);
00098 }


Member Data Documentation

ACE_Allocator* TAO_Queued_Data::allocator_ [private]
 

The allocator used to allocate this class.

Definition at line 306 of file Incoming_Message_Queue.h.

Referenced by duplicate, and release.

CORBA::Octet TAO_Queued_Data::byte_order_
 

The byte order of the message that is stored in the node.

Definition at line 275 of file Incoming_Message_Queue.h.

Referenced by TAO_GIOP_Message_Lite::process_request_message, and TAO_GIOP_Message_Base::process_request_message.

Queued_Data_State TAO_Queued_Data::current_state_
 

Indicates the current state of the message, including hints at how to interpret the value stored in missing_data_bytes_.

Definition at line 268 of file Incoming_Message_Queue.h.

Referenced by TAO_Transport::handle_input_i, make_completed_message, and make_uncompleted_message.

CORBA::Octet TAO_Queued_Data::major_version_
 

Many protocols like GIOP have a major and minor version information that would be needed to read and decipher the message.

Definition at line 280 of file Incoming_Message_Queue.h.

Referenced by TAO_Transport::enqueue_incoming_message, TAO_Incoming_Message_Queue::find_fragment, TAO_GIOP_Message_Lite::process_request_message, and TAO_GIOP_Message_Base::process_request_message.

CORBA::Octet TAO_Queued_Data::minor_version_
 

Definition at line 281 of file Incoming_Message_Queue.h.

Referenced by TAO_Transport::enqueue_incoming_message, TAO_Incoming_Message_Queue::find_fragment, TAO_GIOP_Message_Lite::process_request_message, and TAO_GIOP_Message_Base::process_request_message.

size_t TAO_Queued_Data::missing_data_bytes_
 

Data missing in the above message that hasn't been read or processed yet.

Definition at line 271 of file Incoming_Message_Queue.h.

Referenced by TAO_Incoming_Message_Queue::copy_tail, TAO_Transport::handle_input_i, TAO_Incoming_Message_Queue::is_head_complete, TAO_Incoming_Message_Queue::is_tail_complete, make_completed_message, make_uncompleted_message, TAO_Incoming_Message_Queue::missing_data_tail, and TAO_Transport::try_to_complete.

CORBA::Octet TAO_Queued_Data::more_fragments_
 

Some messages can be fragmented by the protocol (this is an ORB level fragmentation on top of the TCP/IP fragmentation. This member indicates whether the message that we have recd. and queue already has more fragments that is missing..

Definition at line 287 of file Incoming_Message_Queue.h.

Referenced by consolidate, TAO_Transport::enqueue_incoming_message, TAO_Incoming_Message_Queue::find_fragment, TAO_Incoming_Message_Queue::is_head_complete, and TAO_Incoming_Message_Queue::is_tail_fragmented.

ACE_Message_Block* TAO_Queued_Data::msg_block_
 

The message block that contains the message.

Definition at line 236 of file Incoming_Message_Queue.h.

Referenced by consolidate, TAO_Incoming_Message_Queue::copy_tail, duplicate, TAO_Transport::enqueue_incoming_message, TAO_Transport::handle_input_i, make_completed_message, make_uncompleted_message, TAO_GIOP_Message_Lite::process_request_message, TAO_GIOP_Message_Base::process_request_message, release, and TAO_Transport::try_to_complete.

TAO_Pluggable_Message_Type TAO_Queued_Data::msg_type_
 

The message type of the message.

Definition at line 293 of file Incoming_Message_Queue.h.

Referenced by TAO_Transport::process_parsed_messages, TAO_GIOP_Message_Lite::process_request_message, and TAO_GIOP_Message_Base::process_request_message.

TAO_Queued_Data* TAO_Queued_Data::next_
 

Pounter to the next element in the queue.

Definition at line 296 of file Incoming_Message_Queue.h.

Referenced by TAO_Incoming_Message_Queue::dequeue_head, TAO_Incoming_Message_Queue::dequeue_tail, TAO_Incoming_Message_Queue::enqueue_tail, TAO_Incoming_Message_Queue::find_fragment, and TAO_Incoming_Message_Queue::is_head_complete.

CORBA::ULong TAO_Queued_Data::request_id_
 

The fragment request id.

Definition at line 290 of file Incoming_Message_Queue.h.

Referenced by TAO_Transport::enqueue_incoming_message, and TAO_Incoming_Message_Queue::find_fragment.


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