TAO: TAO_Queued_Data class Reference

00174   : msg_block_ (0),
00175     missing_data_ (0),
00176     major_version_ (0),
00177     minor_version_ (0),
00178     byte_order_ (0),
00179     more_fragments_ (0),
00180     msg_type_ (TAO_PLUGGABLE_MESSAGE_MESSAGERROR),
00181     next_ (0),
00182     allocator_ (alloc)
00183 {
00184 }

00188   : msg_block_ (mb),
00189     missing_data_ (0),
00190     major_version_ (0),
00191     minor_version_ (0),
00192     byte_order_ (0),
00193     more_fragments_ (0),
00194     msg_type_ (TAO_PLUGGABLE_MESSAGE_MESSAGERROR),
00195     next_ (0),
00196     allocator_ (alloc)
00197 {
00198 }

00201   : msg_block_ (qd.msg_block_->duplicate ()),
00202     missing_data_ (qd.missing_data_),
00203     major_version_ (qd.major_version_),
00204     minor_version_ (qd.minor_version_),
00205     byte_order_ (qd.byte_order_),
00206     more_fragments_ (qd.more_fragments_),
00207     msg_type_ (qd.msg_type_),
00208     next_ (0),
00209     allocator_ (qd.allocator_)
00210 {
00211 }

00325 {
00326   // Is this a chain of fragments?
00327   if (this->more_fragments_ && this->msg_block_->cont () != 0)
00328     {
00329       // Create a message block big enough to hold the entire chain
00330       ACE_Message_Block *dest = clone_mb_nocopy_size (
00331                                       this->msg_block_,
00332                                       this->msg_block_->total_length ());
00333 
00334       if (0 == dest)
00335         {
00336           // out of memory
00337           return -1;
00338         }
00339       // Memory allocation succeeded, the new message block can hold the consolidated
00340       // message. The following code just copies all the data into this new message block.
00341       // No further memory allocation will take place.
00342 
00343       // Reset the cont() parameter.  We have cloned the message
00344       // block but not the chain as we will no longer have chain.
00345       dest->cont (0);
00346 
00347       // Use ACE_CDR to consolidate the chain for us
00348       ACE_CDR::consolidate (dest, this->msg_block_);
00349 
00350       // free the original message block chain
00351       this->msg_block_->release ();
00352 
00353       // Set the message block to the new consolidated message block
00354       this->msg_block_ = dest;
00355       this->more_fragments_ = 0;
00356     }
00357 
00358   return 0;
00359 }

00278 {
00279   // Check to see if the underlying block is on the stack. If not it
00280   // is fine. If the datablock is on stack, try to make a copy of that
00281   // before doing a duplicate.
00282   // @@ todo: Theoretically this should be within the Message Block,
00283   // but we dont have much scope to do this in that mess. Probably in
00284   // the next stage of MB rewrite we should be okay
00285   ACE_Message_Block::Message_Flags fl =
00286     sqd.msg_block_->self_flags ();
00287 
00288   if (ACE_BIT_ENABLED (fl,
00289                        ACE_Message_Block::DONT_DELETE))
00290     (void) TAO_Queued_Data::replace_data_block (*sqd.msg_block_);
00291 
00292 
00293   TAO_Queued_Data *qd = 0;
00294 
00295   if (sqd.allocator_)
00296     {
00297       ACE_NEW_MALLOC_RETURN (qd,
00298                              static_cast<TAO_Queued_Data *> (
00299                                sqd.allocator_->malloc (sizeof (TAO_Queued_Data))),
00300                              TAO_Queued_Data (sqd),
00301                              0);
00302 
00303       return qd;
00304     }
00305 
00306   // No allocator, so use the global pool!
00307   // @@ TODO: We should be removing this at some point of time!
00308   if (TAO_debug_level == 4)
00309     {
00310       // This debug is for testing purposes!
00311       ACE_DEBUG ((LM_DEBUG,
00312                   "TAO (%P|%t) - Queued_Data[%d]::duplicate\n",
00313                   "Using global pool for allocation \n"));
00314     }
00315 
00316   ACE_NEW_RETURN (qd,
00317                   TAO_Queued_Data (sqd),
00318                   0);
00319 
00320   return qd;
00321 }

00216 {
00217   TAO_Queued_Data *qd = 0;
00218 
00219   if (alloc)
00220     {
00221       ACE_NEW_MALLOC_RETURN (qd,
00222                              static_cast<TAO_Queued_Data *> (
00223                                alloc->malloc (sizeof (TAO_Queued_Data))),
00224                              TAO_Queued_Data (alloc),
00225                              0);
00226 
00227       return qd;
00228     }
00229 
00230   // No allocator, so use the global pool!
00231   // @@ TODO: We should be removing this at some point of time!
00232   if (TAO_debug_level == 4)
00233     {
00234       // This debug is for testing purposes!
00235       ACE_DEBUG ((LM_DEBUG,
00236                   "TAO (%P|%t) - Queued_Data::get_queued_data\n"
00237                   "Using global pool for allocation \n"));
00238     }
00239 
00240   ACE_NEW_RETURN (qd,
00241                   TAO_Queued_Data,
00242                   0);
00243 
00244   return qd;
00245 }

00250 {
00251   //// TODO
00252   ACE_Message_Block::release (qd->msg_block_);
00253 
00254   if (qd->allocator_)
00255     {
00256       ACE_DES_FREE (qd,
00257                     qd->allocator_->free,
00258                     TAO_Queued_Data);
00259 
00260       return;
00261     }
00262 
00263   // @@todo: Need to be removed at some point of time!
00264   if (TAO_debug_level == 4)
00265     {
00266       // This debug is for testing purposes!
00267       ACE_DEBUG ((LM_DEBUG,
00268                   "TAO (%P|%t) - Queued_Data[%d]::release\n",
00269                   "Using global pool for releasing \n"));
00270     }
00271   delete qd;
00272 
00273 }

00023 {
00024   size_t const newsize =
00025     ACE_CDR::total_length (&mb, 0) + ACE_CDR::MAX_ALIGNMENT;
00026 
00027   ACE_Data_Block *db =
00028     mb.data_block ()->clone_nocopy ();
00029 
00030   if (db->size (newsize) == -1)
00031     return;
00032 
00033   ACE_Message_Block tmp (db);
00034   ACE_CDR::mb_align (&tmp);
00035 
00036   tmp.copy (mb.rd_ptr (), mb.length());
00037   mb.data_block (tmp.data_block ()->duplicate ());
00038 
00039   mb.rd_ptr (tmp.rd_ptr ());
00040   mb.wr_ptr (tmp.wr_ptr ());
00041 
00042   // Remove the DONT_DELETE flags from mb
00043   mb.clr_self_flags (ACE_Message_Block::DONT_DELETE);
00044 }


Public Member Functions
	TAO_Queued_Data (ACE_Allocator *alloc=0)
	Default Constructor.
	TAO_Queued_Data (ACE_Message_Block mb, ACE_Allocator alloc=0)
	Constructor.
	TAO_Queued_Data (const TAO_Queued_Data &qd)
	Copy constructor.
int	consolidate (void)
Static Public Member Functions
TAO_Queued_Data *	make_queued_data (ACE_Allocator *alloc=0)
	Creation of a node in the queue.
void	release (TAO_Queued_Data *qd)
	Deletion of a node from the queue.
TAO_Queued_Data *	duplicate (TAO_Queued_Data &qd)
Public Attributes
ACE_Message_Block *	msg_block_
	The message block that contains the message.
CORBA::Octet	major_version_
CORBA::Octet	minor_version_
CORBA::Octet	byte_order_
	The byte order of the message that is stored in the node.
CORBA::Octet	more_fragments_
TAO_Pluggable_Message_Type	msg_type_
	The message type of the message.
TAO_Queued_Data *	next_
	Pounter to the next element in the queue.
Missing Data details
The missing_data_ member contains the number of bytes of data missing from msg_block_.
size_t	missing_data_
Static Private Member Functions
void	replace_data_block (ACE_Message_Block &mb)
Private Attributes
ACE_Allocator *	allocator_
	The allocator used to allocate this class.

TAO_Queued_Data Class Reference

Public Member Functions

Static Public Member Functions

Public Attributes

Static Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation