00001 #include "ace/Message_Block.h"
00002
00003 #if !defined (__ACE_INLINE__)
00004 #include "ace/Message_Block.inl"
00005 #endif
00006
00007 #include "ace/Guard_T.h"
00008 #include "ace/Log_Msg.h"
00009 #include "ace/Malloc_Base.h"
00010 #include "ace/OS_NS_string.h"
00011
00012
00013 #include "ace/Timeprobe.h"
00014
00015 ACE_RCSID (ace,
00016 Message_Block,
00017 "$Id: Message_Block.cpp 84527 2009-02-19 14:01:42Z johnnyw $")
00018
00019 ACE_BEGIN_VERSIONED_NAMESPACE_DECL
00020
00021 ACE_ALLOC_HOOK_DEFINE (ACE_Message_Block)
00022
00023 #if defined (ACE_ENABLE_TIMEPROBES)
00024
00025 static const char *ACE_MB_Timeprobe_Description[] =
00026 {
00027 "Message_Block::init_i - enter",
00028 "Message_Block::init_i - leave",
00029 "Message_Block::init_i - db alloc",
00030 "Message_Block::init_i - db ctor",
00031 "Data_Block::ctor[1] - enter",
00032 "Data_Block::ctor[1] - leave",
00033 "Data_Block::ctor[2] - enter",
00034 "Data_Block::ctor[2] - leave",
00035 "Data_Block::clone - enter",
00036 "Data_Block::clone - leave"
00037 };
00038
00039 enum
00040 {
00041 ACE_MESSAGE_BLOCK_INIT_I_ENTER = 3000,
00042 ACE_MESSAGE_BLOCK_INIT_I_LEAVE,
00043 ACE_MESSAGE_BLOCK_INIT_I_DB_ALLOC,
00044 ACE_MESSAGE_BLOCK_INIT_I_DB_CTOR,
00045 ACE_DATA_BLOCK_CTOR1_ENTER,
00046 ACE_DATA_BLOCK_CTOR1_LEAVE,
00047 ACE_DATA_BLOCK_CTOR2_ENTER,
00048 ACE_DATA_BLOCK_CTOR2_LEAVE,
00049 ACE_DATA_BLOCK_CLONE_ENTER,
00050 ACE_DATA_BLOCK_CLONE_LEAVE
00051 };
00052
00053
00054
00055 ACE_TIMEPROBE_EVENT_DESCRIPTIONS (ACE_MB_Timeprobe_Description,
00056 ACE_MESSAGE_BLOCK_INIT_I_ENTER);
00057
00058 #endif
00059
00060 void
00061 ACE_Message_Block::data_block (ACE_Data_Block *db)
00062 {
00063 ACE_TRACE ("ACE_Message_Block::data_block");
00064 if (ACE_BIT_DISABLED (this->flags_,
00065 ACE_Message_Block::DONT_DELETE)
00066 && this->data_block_ != 0)
00067 this->data_block_->release ();
00068
00069 this->data_block_ = db;
00070
00071
00072
00073 this->rd_ptr (this->data_block ()->base ());
00074 this->wr_ptr (this->data_block ()->base ());
00075 }
00076
00077 int
00078 ACE_Message_Block::copy (const char *buf, size_t n)
00079 {
00080 ACE_TRACE ("ACE_Message_Block::copy");
00081
00082
00083
00084 size_t len = this->space ();
00085
00086 if (len < n)
00087 {
00088 errno = ENOSPC;
00089 return -1;
00090 }
00091 else
00092 {
00093 (void) ACE_OS::memcpy (this->wr_ptr (),
00094 buf,
00095 n);
00096 this->wr_ptr (n);
00097 return 0;
00098 }
00099 }
00100
00101 int
00102 ACE_Message_Block::copy (const char *buf)
00103 {
00104 ACE_TRACE ("ACE_Message_Block::copy");
00105
00106
00107
00108 size_t len = this->space ();
00109
00110 size_t buflen = ACE_OS::strlen (buf) + 1;
00111
00112 if (len < buflen)
00113 {
00114 errno = ENOSPC;
00115 return -1;
00116 }
00117 else
00118 {
00119 (void) ACE_OS::memcpy (this->wr_ptr (),
00120 buf,
00121 buflen);
00122 this->wr_ptr (buflen);
00123 return 0;
00124 }
00125 }
00126
00127 int
00128 ACE_Message_Block::crunch (void)
00129 {
00130 if (this->rd_ptr_ != 0)
00131 {
00132 if (this->rd_ptr_ > this->wr_ptr_)
00133 return -1;
00134
00135 size_t const len = this->length ();
00136 (void) ACE_OS::memmove (this->base (),
00137 this->rd_ptr (),
00138 len);
00139 this->rd_ptr (this->base ());
00140 this->wr_ptr (this->base () + len);
00141 }
00142 return 0;
00143 }
00144
00145 void
00146 ACE_Data_Block::dump (void) const
00147 {
00148 #if defined (ACE_HAS_DUMP)
00149 ACE_TRACE ("ACE_Data_Block::dump");
00150 ACE_DEBUG ((LM_DEBUG, ACE_BEGIN_DUMP, this));
00151 ACE_DEBUG ((LM_DEBUG,
00152 ACE_TEXT ("-----( Data Block )-----\n")
00153 ACE_TEXT ("type_ = %d\n")
00154 ACE_TEXT ("cur_size_ = %u\n")
00155 ACE_TEXT ("max_size_ = %u\n")
00156 ACE_TEXT ("flags_ = %u\n")
00157 ACE_TEXT ("base_ = %@\n")
00158 ACE_TEXT ("locking_strategy_ = %u\n")
00159 ACE_TEXT ("reference_count_ = %u\n")
00160 ACE_TEXT ("---------------------------\n"),
00161 this->type_,
00162 this->cur_size_,
00163 this->max_size_,
00164 this->flags_,
00165 this->base_,
00166 this->locking_strategy_,
00167 this->reference_count_));
00168 this->allocator_strategy_->dump ();
00169 ACE_DEBUG ((LM_DEBUG, ACE_END_DUMP));
00170 #endif
00171 }
00172
00173 void
00174 ACE_Message_Block::dump (void) const
00175 {
00176 #if defined (ACE_HAS_DUMP)
00177 ACE_TRACE ("ACE_Message_Block::dump");
00178 ACE_DEBUG ((LM_DEBUG, ACE_BEGIN_DUMP, this));
00179 ACE_DEBUG ((LM_DEBUG,
00180 ACE_TEXT ("-----( Message Block )-----\n")
00181 ACE_TEXT ("priority_ = %d\n")
00182 ACE_TEXT ("next_ = %@\n")
00183 ACE_TEXT ("prev_ = %@\n")
00184 ACE_TEXT ("cont_ = %@\n")
00185 ACE_TEXT ("rd_ptr_ = %@\n")
00186 ACE_TEXT ("wr_ptr_ = %@\n")
00187 ACE_TEXT ("---------------------------\n"),
00188 this->priority_,
00189 this->next_,
00190 this->prev_,
00191 this->cont_,
00192 this->rd_ptr_,
00193 this->wr_ptr_));
00194 this->data_block ()->dump ();
00195 ACE_DEBUG ((LM_DEBUG, ACE_END_DUMP));
00196 #endif
00197 }
00198
00199 int
00200 ACE_Data_Block::reference_count (void) const
00201 {
00202 if (this->locking_strategy_)
00203 {
00204
00205 ACE_GUARD_RETURN (ACE_Lock, ace_mon, *this->locking_strategy_, 0);
00206
00207 return this->reference_count_i ();
00208 }
00209
00210 return this->reference_count_i ();
00211 }
00212
00213 int
00214 ACE_Data_Block::size (size_t length)
00215 {
00216 ACE_TRACE ("ACE_Data_Block::size");
00217
00218 if (length <= this->max_size_)
00219 this->cur_size_ = length;
00220 else
00221 {
00222
00223 char *buf = 0;
00224 ACE_ALLOCATOR_RETURN (buf,
00225 (char *) this->allocator_strategy_->malloc (length),
00226 -1);
00227
00228 ACE_OS::memcpy (buf,
00229 this->base_,
00230 this->cur_size_);
00231 if (ACE_BIT_DISABLED (this->flags_,
00232 ACE_Message_Block::DONT_DELETE))
00233 this->allocator_strategy_->free ((void *) this->base_);
00234 else
00235
00236 ACE_CLR_BITS (this->flags_,
00237 ACE_Message_Block::DONT_DELETE);
00238 this->max_size_ = length;
00239 this->cur_size_ = length;
00240 this->base_ = buf;
00241 }
00242 return 0;
00243 }
00244
00245 int
00246 ACE_Message_Block::size (size_t length)
00247 {
00248 ACE_TRACE ("ACE_Message_Block::size");
00249
00250
00251 if (this->data_block ()->size (length) == -1)
00252 return -1;
00253
00254 return 0;
00255 }
00256
00257 void
00258 ACE_Message_Block::total_size_and_length (size_t &mb_size,
00259 size_t &mb_length) const
00260 {
00261 ACE_TRACE ("ACE_Message_Block::total_size_and_length");
00262
00263 for (const ACE_Message_Block *i = this;
00264 i != 0;
00265 i = i->cont ())
00266 {
00267 mb_size += i->size ();
00268 mb_length += i->length ();
00269 }
00270 }
00271
00272 size_t
00273 ACE_Message_Block::total_size (void) const
00274 {
00275 ACE_TRACE ("ACE_Message_Block::total_size");
00276
00277 size_t size = 0;
00278 for (const ACE_Message_Block *i = this;
00279 i != 0;
00280 i = i->cont ())
00281 size += i->size ();
00282
00283 return size;
00284 }
00285
00286 size_t
00287 ACE_Message_Block::total_length (void) const
00288 {
00289 ACE_TRACE ("ACE_Message_Block::total_length");
00290
00291 size_t length = 0;
00292 for (const ACE_Message_Block *i = this;
00293 i != 0;
00294 i = i->cont ())
00295 length += i->length ();
00296
00297 return length;
00298 }
00299
00300 size_t
00301 ACE_Message_Block::total_capacity (void) const
00302 {
00303 ACE_TRACE ("ACE_Message_Block::total_capacity");
00304
00305 size_t size = 0;
00306
00307 for (const ACE_Message_Block *i = this;
00308 i != 0;
00309 i = i->cont ())
00310 size += i->capacity ();
00311
00312 return size;
00313 }
00314
00315 ACE_Data_Block::ACE_Data_Block (void)
00316 : type_ (ACE_Message_Block::MB_DATA),
00317 cur_size_ (0),
00318 max_size_ (0),
00319 flags_ (ACE_Message_Block::DONT_DELETE),
00320 base_ (0),
00321 allocator_strategy_ (0),
00322 locking_strategy_ (0),
00323 reference_count_ (1),
00324 data_block_allocator_ (0)
00325 {
00326 ACE_TRACE ("ACE_Data_Block::ACE_Data_Block");
00327 ACE_FUNCTION_TIMEPROBE (ACE_DATA_BLOCK_CTOR1_ENTER);
00328
00329 ACE_ALLOCATOR (this->allocator_strategy_,
00330 ACE_Allocator::instance ());
00331
00332 ACE_ALLOCATOR (this->data_block_allocator_,
00333 ACE_Allocator::instance ());
00334 }
00335
00336 ACE_Data_Block::ACE_Data_Block (size_t size,
00337 ACE_Message_Block::ACE_Message_Type msg_type,
00338 const char *msg_data,
00339 ACE_Allocator *allocator_strategy,
00340 ACE_Lock *locking_strategy,
00341 ACE_Message_Block::Message_Flags flags,
00342 ACE_Allocator *data_block_allocator)
00343 : type_ (msg_type),
00344 cur_size_ (0),
00345 max_size_ (0),
00346 flags_ (flags),
00347 base_ (const_cast <char *> (msg_data)),
00348 allocator_strategy_ (allocator_strategy),
00349 locking_strategy_ (locking_strategy),
00350 reference_count_ (1),
00351 data_block_allocator_ (data_block_allocator)
00352 {
00353 ACE_TRACE ("ACE_Data_Block::ACE_Data_Block");
00354 ACE_FUNCTION_TIMEPROBE (ACE_DATA_BLOCK_CTOR2_ENTER);
00355
00356
00357
00358 if (this->allocator_strategy_ == 0)
00359 ACE_ALLOCATOR (this->allocator_strategy_,
00360 ACE_Allocator::instance ());
00361
00362 if (this->data_block_allocator_ == 0)
00363 ACE_ALLOCATOR (this->data_block_allocator_,
00364 ACE_Allocator::instance ());
00365
00366 if (msg_data == 0)
00367 {
00368 ACE_ALLOCATOR (this->base_,
00369 (char *) this->allocator_strategy_->malloc (size));
00370 #if defined (ACE_INITIALIZE_MEMORY_BEFORE_USE)
00371 (void) ACE_OS::memset (this->base_,
00372 '\0',
00373 size);
00374 #endif
00375 }
00376
00377
00378
00379 if (this->base_ == 0)
00380 {
00381 size = 0;
00382 }
00383
00384
00385
00386 this->cur_size_ = this->max_size_ = size;
00387 }
00388
00389 ACE_Message_Block::ACE_Message_Block (const char *data,
00390 size_t size,
00391 unsigned long priority)
00392 : flags_ (0),
00393 data_block_ (0)
00394 {
00395 ACE_TRACE ("ACE_Message_Block::ACE_Message_Block");
00396
00397 if (this->init_i (size,
00398 MB_DATA,
00399 0,
00400 data,
00401 0,
00402 0,
00403 ACE_Message_Block::DONT_DELETE,
00404 priority,
00405 ACE_Time_Value::zero,
00406 ACE_Time_Value::max_time,
00407 0,
00408 0,
00409 0) == -1)
00410 ACE_ERROR ((LM_ERROR,
00411 ACE_TEXT ("ACE_Message_Block")));
00412 }
00413
00414 ACE_Message_Block::ACE_Message_Block (ACE_Allocator *message_block_allocator)
00415 : flags_ (0),
00416 data_block_ (0)
00417 {
00418 ACE_TRACE ("ACE_Message_Block::ACE_Message_Block");
00419
00420 if (this->init_i (0,
00421 MB_DATA,
00422 0,
00423 0,
00424 0,
00425 0,
00426 ACE_Message_Block::DONT_DELETE,
00427 0,
00428 ACE_Time_Value::zero,
00429 ACE_Time_Value::max_time,
00430 0,
00431 0,
00432 message_block_allocator) == -1)
00433 ACE_ERROR ((LM_ERROR,
00434 ACE_TEXT ("ACE_Message_Block")));
00435 }
00436
00437 ACE_Message_Block::ACE_Message_Block (size_t size,
00438 ACE_Message_Type msg_type,
00439 ACE_Message_Block *msg_cont,
00440 const char *msg_data,
00441 ACE_Allocator *allocator_strategy,
00442 ACE_Lock *locking_strategy,
00443 unsigned long priority,
00444 const ACE_Time_Value &execution_time,
00445 const ACE_Time_Value &deadline_time,
00446 ACE_Allocator *data_block_allocator,
00447 ACE_Allocator *message_block_allocator)
00448 :flags_ (0),
00449 data_block_ (0)
00450 {
00451 ACE_TRACE ("ACE_Message_Block::ACE_Message_Block");
00452
00453 if (this->init_i (size,
00454 msg_type,
00455 msg_cont,
00456 msg_data,
00457 allocator_strategy,
00458 locking_strategy,
00459 msg_data ? ACE_Message_Block::DONT_DELETE : 0,
00460 priority,
00461 execution_time,
00462 deadline_time,
00463 0,
00464 data_block_allocator,
00465 message_block_allocator) == -1)
00466 ACE_ERROR ((LM_ERROR,
00467 ACE_TEXT ("ACE_Message_Block")));
00468 }
00469
00470 int
00471 ACE_Message_Block::init (size_t size,
00472 ACE_Message_Type msg_type,
00473 ACE_Message_Block *msg_cont,
00474 const char *msg_data,
00475 ACE_Allocator *allocator_strategy,
00476 ACE_Lock *locking_strategy,
00477 unsigned long priority,
00478 const ACE_Time_Value &execution_time,
00479 const ACE_Time_Value &deadline_time,
00480 ACE_Allocator *data_block_allocator,
00481 ACE_Allocator *message_block_allocator)
00482 {
00483 ACE_TRACE ("ACE_Message_Block::init");
00484
00485 return this->init_i (size,
00486 msg_type,
00487 msg_cont,
00488 msg_data,
00489 allocator_strategy,
00490 locking_strategy,
00491 msg_data ? ACE_Message_Block::DONT_DELETE : 0,
00492 priority,
00493 execution_time,
00494 deadline_time,
00495 0,
00496 data_block_allocator,
00497 message_block_allocator);
00498 }
00499
00500 int
00501 ACE_Message_Block::init (const char *data,
00502 size_t size)
00503 {
00504 ACE_TRACE ("ACE_Message_Block::init");
00505
00506
00507 return this->init_i (size,
00508 MB_DATA,
00509 0,
00510 data,
00511 0,
00512 0,
00513 ACE_Message_Block::DONT_DELETE,
00514 0,
00515 ACE_Time_Value::zero,
00516 ACE_Time_Value::max_time,
00517 0,
00518 0,
00519 0);
00520 }
00521
00522 ACE_Message_Block::ACE_Message_Block (size_t size,
00523 ACE_Message_Type msg_type,
00524 ACE_Message_Block *msg_cont,
00525 const char *msg_data,
00526 ACE_Allocator *allocator_strategy,
00527 ACE_Lock *locking_strategy,
00528 Message_Flags flags,
00529 unsigned long priority,
00530 const ACE_Time_Value &execution_time,
00531 const ACE_Time_Value &deadline_time,
00532 ACE_Data_Block *db,
00533 ACE_Allocator *data_block_allocator,
00534 ACE_Allocator *message_block_allocator)
00535 : flags_ (0),
00536 data_block_ (0)
00537 {
00538 ACE_TRACE ("ACE_Message_Block::ACE_Message_Block");
00539
00540 if (this->init_i (size,
00541 msg_type,
00542 msg_cont,
00543 msg_data,
00544 allocator_strategy,
00545 locking_strategy,
00546 flags,
00547 priority,
00548 execution_time,
00549 deadline_time,
00550 db,
00551 data_block_allocator,
00552 message_block_allocator) == -1)
00553 ACE_ERROR ((LM_ERROR,
00554 ACE_TEXT ("ACE_Message_Block")));
00555 }
00556
00557 ACE_Message_Block::ACE_Message_Block (ACE_Data_Block *data_block,
00558 ACE_Message_Block::Message_Flags flags,
00559 ACE_Allocator *message_block_allocator)
00560 : flags_ (flags),
00561 data_block_ (0)
00562 {
00563 ACE_TRACE ("ACE_Message_Block::ACE_Message_Block");
00564
00565 if (this->init_i (0,
00566 MB_NORMAL,
00567 0,
00568 0,
00569 0,
00570 0,
00571 0,
00572 0,
00573 ACE_Time_Value::zero,
00574 ACE_Time_Value::max_time,
00575 data_block,
00576 data_block->data_block_allocator (),
00577 message_block_allocator) == -1)
00578 ACE_ERROR ((LM_ERROR,
00579 ACE_TEXT ("ACE_Message_Block")));
00580 }
00581
00582 ACE_Message_Block::ACE_Message_Block (const ACE_Message_Block &mb,
00583 size_t align)
00584 :flags_ (0),
00585 data_block_ (0)
00586 {
00587 ACE_TRACE ("ACE_Message_Block::ACE_Message_Block");
00588
00589 if (ACE_BIT_DISABLED (mb.flags_,
00590 ACE_Message_Block::DONT_DELETE))
00591 {
00592 if (this->init_i (0,
00593 MB_NORMAL,
00594 0,
00595 0,
00596 0,
00597 0,
00598 0,
00599 0,
00600 ACE_Time_Value::zero,
00601 ACE_Time_Value::max_time,
00602 mb.data_block ()->duplicate (),
00603 mb.data_block ()->data_block_allocator (),
00604 mb.message_block_allocator_) == -1)
00605 ACE_ERROR ((LM_ERROR,
00606 ACE_TEXT ("ACE_Message_Block")));
00607 #if !defined (ACE_LACKS_CDR_ALIGNMENT)
00608
00609 char *start = ACE_ptr_align_binary (this->base (),
00610 align);
00611 #else
00612 char *start = this->base ();
00613 #endif
00614
00615
00616 this->rd_ptr (start);
00617 this->wr_ptr (start);
00618
00619 }
00620 else
00621 {
00622 if (this->init_i (0,
00623 MB_NORMAL,
00624 0,
00625 0,
00626 0,
00627 0,
00628 0,
00629 0,
00630 ACE_Time_Value::zero,
00631 ACE_Time_Value::max_time,
00632 mb.data_block ()->clone_nocopy (),
00633 mb.data_block ()->data_block_allocator (),
00634 mb.message_block_allocator_) == -1)
00635 ACE_ERROR ((LM_ERROR,
00636 ACE_TEXT ("ACE_Message_Block")));
00637
00638 #if !defined (ACE_LACKS_CDR_ALIGNMENT)
00639
00640 char *start = ACE_ptr_align_binary (this->base (),
00641 align);
00642 #else
00643 char *start = this->base ();
00644 #endif
00645
00646
00647 this->rd_ptr (start);
00648 this->wr_ptr (start);
00649
00650 #if !defined (ACE_LACKS_CDR_ALIGNMENT)
00651
00652 start = ACE_ptr_align_binary (mb.base (),
00653 align);
00654 #else
00655 start = mb.base ();
00656 #endif
00657
00658
00659
00660 size_t const wr_offset = mb.wr_ptr_ - (start - mb.base ());
00661
00662
00663 (void) ACE_OS::memcpy (this->wr_ptr (),
00664 start,
00665 wr_offset);
00666
00667
00668
00669
00670 }
00671 #if defined (ACE_LACKS_CDR_ALIGNMENT)
00672 ACE_UNUSED_ARG (align);
00673 #endif
00674 }
00675
00676 int
00677 ACE_Message_Block::init_i (size_t size,
00678 ACE_Message_Type msg_type,
00679 ACE_Message_Block *msg_cont,
00680 const char *msg_data,
00681 ACE_Allocator *allocator_strategy,
00682 ACE_Lock *locking_strategy,
00683 Message_Flags flags,
00684 unsigned long priority,
00685 const ACE_Time_Value &execution_time,
00686 const ACE_Time_Value &deadline_time,
00687 ACE_Data_Block *db,
00688 ACE_Allocator *data_block_allocator,
00689 ACE_Allocator *message_block_allocator)
00690 {
00691 ACE_TRACE ("ACE_Message_Block::init_i");
00692 ACE_FUNCTION_TIMEPROBE (ACE_MESSAGE_BLOCK_INIT_I_ENTER);
00693
00694 this->rd_ptr_ = 0;
00695 this->wr_ptr_ = 0;
00696 this->priority_ = priority;
00697 #if defined (ACE_HAS_TIMED_MESSAGE_BLOCKS)
00698 this->execution_time_ = execution_time;
00699 this->deadline_time_ = deadline_time;
00700 #else
00701 ACE_UNUSED_ARG (execution_time);
00702 ACE_UNUSED_ARG (deadline_time);
00703 #endif
00704 this->cont_ = msg_cont;
00705 this->next_ = 0;
00706 this->prev_ = 0;
00707
00708 this->message_block_allocator_ = message_block_allocator;
00709
00710 if (this->data_block_ != 0)
00711 {
00712 this->data_block_->release ();
00713 this->data_block_ = 0;
00714 }
00715
00716 if (db == 0)
00717 {
00718 if (data_block_allocator == 0)
00719 ACE_ALLOCATOR_RETURN (data_block_allocator,
00720 ACE_Allocator::instance (),
00721 -1);
00722
00723 ACE_TIMEPROBE (ACE_MESSAGE_BLOCK_INIT_I_DB_ALLOC);
00724
00725
00726
00727 ACE_NEW_MALLOC_RETURN (db,
00728 static_cast<ACE_Data_Block *> (
00729 data_block_allocator->malloc (sizeof (ACE_Data_Block))),
00730 ACE_Data_Block (size,
00731 msg_type,
00732 msg_data,
00733 allocator_strategy,
00734 locking_strategy,
00735 flags,
00736 data_block_allocator),
00737 -1);
00738 ACE_TIMEPROBE (ACE_MESSAGE_BLOCK_INIT_I_DB_CTOR);
00739
00740
00741
00742
00743 if (db != 0 && db->size () < size)
00744 {
00745 db->ACE_Data_Block::~ACE_Data_Block();
00746 data_block_allocator->free (db);
00747 errno = ENOMEM;
00748 return -1;
00749 }
00750 }
00751
00752
00753 this->data_block (db);
00754
00755 return 0;
00756 }
00757
00758 ACE_Data_Block::~ACE_Data_Block (void)
00759 {
00760
00761 ACE_ASSERT (this->reference_count_ <= 1);
00762
00763
00764 this->reference_count_ = 0;
00765
00766 if (ACE_BIT_DISABLED (this->flags_,
00767 ACE_Message_Block::DONT_DELETE))
00768 {
00769 this->allocator_strategy_->free ((void *) this->base_);
00770 this->base_ = 0;
00771 }
00772 }
00773
00774 ACE_Data_Block *
00775 ACE_Data_Block::release_i (void)
00776 {
00777 ACE_TRACE ("ACE_Data_Block::release_i");
00778
00779 ACE_ASSERT (this->reference_count_ > 0);
00780
00781 ACE_Data_Block *result = 0;
00782
00783
00784 --this->reference_count_;
00785
00786 if (this->reference_count_ == 0)
00787
00788 result = 0;
00789 else
00790 result = this;
00791
00792 return result;
00793 }
00794
00795 ACE_Data_Block *
00796 ACE_Data_Block::release_no_delete (ACE_Lock *lock)
00797 {
00798 ACE_TRACE ("ACE_Data_Block::release_no_delete");
00799
00800 ACE_Data_Block *result = 0;
00801 ACE_Lock *lock_to_be_used = 0;
00802
00803
00804 if (lock != 0)
00805 {
00806
00807 if (lock == this->locking_strategy_)
00808
00809 lock_to_be_used = 0;
00810
00811
00812 else
00813
00814 lock_to_be_used = this->locking_strategy_;
00815 }
00816
00817 else
00818 {
00819
00820 lock_to_be_used = this->locking_strategy_;
00821 }
00822
00823
00824
00825 if (lock_to_be_used != 0)
00826 {
00827 ACE_GUARD_RETURN (ACE_Lock, ace_mon, *lock_to_be_used, 0);
00828
00829 result = this->release_i ();
00830 }
00831 else
00832 {
00833 result = this->release_i ();
00834 }
00835
00836 return result;
00837 }
00838
00839 ACE_Data_Block *
00840 ACE_Data_Block::release (ACE_Lock *lock)
00841 {
00842 ACE_TRACE ("ACE_Data_Block::release");
00843
00844 ACE_Allocator *allocator = this->data_block_allocator_;
00845
00846 ACE_Data_Block *result = this->release_no_delete (lock);
00847
00848
00849
00850
00851 if (result == 0)
00852 ACE_DES_FREE (this,
00853 allocator->free,
00854 ACE_Data_Block);
00855 return result;
00856 }
00857
00858 ACE_Message_Block *
00859 ACE_Message_Block::release (void)
00860 {
00861 ACE_TRACE ("ACE_Message_Block::release");
00862
00863
00864
00865
00866 ACE_Data_Block *tmp = this->data_block ();
00867
00868
00869 int destroy_dblock = 0;
00870
00871 ACE_Lock *lock = 0;
00872
00873
00874 if (this->data_block ())
00875 {
00876
00877 lock = this->data_block ()->locking_strategy ();
00878
00879
00880 if (lock != 0)
00881 {
00882
00883 ACE_GUARD_RETURN (ACE_Lock, ace_mon, *lock, 0);
00884
00885
00886 destroy_dblock = this->release_i (lock);
00887 }
00888
00889 else
00890
00891 destroy_dblock = this->release_i (0);
00892 }
00893 else
00894
00895 destroy_dblock = this->release_i (0);
00896
00897 if (destroy_dblock != 0)
00898 {
00899 ACE_Allocator *allocator = tmp->data_block_allocator ();
00900 ACE_DES_FREE (tmp,
00901 allocator->free,
00902 ACE_Data_Block);
00903 }
00904
00905 return 0;
00906 }
00907
00908 int
00909 ACE_Message_Block::release_i (ACE_Lock *lock)
00910 {
00911 ACE_TRACE ("ACE_Message_Block::release_i");
00912
00913
00914 if (this->cont_)
00915 {
00916 ACE_Message_Block *mb = this->cont_;
00917 ACE_Message_Block *tmp = 0;
00918
00919 do
00920 {
00921 tmp = mb;
00922 mb = mb->cont_;
00923 tmp->cont_ = 0;
00924
00925 ACE_Data_Block *db = tmp->data_block ();
00926 if (tmp->release_i (lock) != 0)
00927 {
00928 ACE_Allocator *allocator = db->data_block_allocator ();
00929 ACE_DES_FREE (db,
00930 allocator->free,
00931 ACE_Data_Block);
00932 }
00933 }
00934 while (mb);
00935
00936 this->cont_ = 0;
00937 }
00938
00939 int result = 0;
00940
00941 if (ACE_BIT_DISABLED (this->flags_,
00942 ACE_Message_Block::DONT_DELETE) &&
00943 this->data_block ())
00944 {
00945 if (this->data_block ()->release_no_delete (lock) == 0)
00946 result = 1;
00947 this->data_block_ = 0;
00948 }
00949
00950
00951
00952 if (this->message_block_allocator_ == 0)
00953 delete this;
00954 else
00955 {
00956 ACE_Allocator *allocator = this->message_block_allocator_;
00957 ACE_DES_FREE (this,
00958 allocator->free,
00959 ACE_Message_Block);
00960 }
00961
00962 return result;
00963 }
00964
00965 ACE_Message_Block *
00966 ACE_Message_Block::release (ACE_Message_Block *mb)
00967 {
00968 ACE_TRACE ("ACE_Message_Block::release");
00969
00970 if (mb != 0)
00971 return mb->release ();
00972 else
00973 return 0;
00974 }
00975
00976 ACE_Message_Block::~ACE_Message_Block (void)
00977 {
00978 ACE_TRACE ("ACE_Message_Block::~ACE_Message_Block");
00979
00980 if (ACE_BIT_DISABLED (this->flags_,
00981 ACE_Message_Block::DONT_DELETE)&&
00982 this->data_block ())
00983 this->data_block ()->release ();
00984
00985 this->prev_ = 0;
00986 this->next_ = 0;
00987 this->cont_ = 0;
00988 }
00989
00990 ACE_Data_Block *
00991 ACE_Data_Block::duplicate (void)
00992 {
00993 ACE_TRACE ("ACE_Data_Block::duplicate");
00994
00995
00996
00997 if (this->locking_strategy_)
00998 {
00999
01000 ACE_GUARD_RETURN (ACE_Lock, ace_mon, *this->locking_strategy_, 0);
01001 ++this->reference_count_;
01002 }
01003 else
01004 ++this->reference_count_;
01005
01006 return this;
01007 }
01008
01009 #if defined (ACE_HAS_TIMED_MESSAGE_BLOCKS)
01010 #define ACE_EXECUTION_TIME this->execution_time_
01011 #define ACE_DEADLINE_TIME this->deadline_time_
01012 #else
01013 #define ACE_EXECUTION_TIME ACE_Time_Value::zero
01014 #define ACE_DEADLINE_TIME ACE_Time_Value::max_time
01015 #endif
01016
01017 ACE_Message_Block *
01018 ACE_Message_Block::duplicate (void) const
01019 {
01020 ACE_TRACE ("ACE_Message_Block::duplicate");
01021
01022 ACE_Message_Block *nb = 0;
01023
01024
01025
01026
01027
01028
01029 if (this->message_block_allocator_ == 0)
01030 ACE_NEW_RETURN (nb,
01031 ACE_Message_Block (0,
01032 ACE_Message_Type (0),
01033 0,
01034 0,
01035 0,
01036 0,
01037 0,
01038 this->priority_,
01039 ACE_EXECUTION_TIME,
01040 ACE_DEADLINE_TIME,
01041
01042
01043
01044
01045 this->data_block ()->duplicate (),
01046 this->data_block ()->data_block_allocator (),
01047 this->message_block_allocator_),
01048 0);
01049 else
01050 ACE_NEW_MALLOC_RETURN (nb,
01051 static_cast<ACE_Message_Block*> (
01052 message_block_allocator_->malloc (sizeof (ACE_Message_Block))),
01053 ACE_Message_Block (0,
01054 ACE_Message_Type (0),
01055 0,
01056 0,
01057 0,
01058 0,
01059 0,
01060 this->priority_,
01061 ACE_EXECUTION_TIME,
01062 ACE_DEADLINE_TIME,
01063
01064
01065
01066
01067 this->data_block ()->duplicate (),
01068 this->data_block ()->data_block_allocator (),
01069 this->message_block_allocator_),
01070 0);
01071
01072
01073
01074
01075
01076 nb->rd_ptr (this->rd_ptr_);
01077 nb->wr_ptr (this->wr_ptr_);
01078
01079
01080 if (this->cont_)
01081 {
01082 nb->cont_ = this->cont_->duplicate ();
01083
01084
01085
01086 if (nb->cont_ == 0)
01087 {
01088 nb->release ();
01089 nb = 0;
01090 }
01091 }
01092
01093 return nb;
01094 }
01095
01096 ACE_Message_Block *
01097 ACE_Message_Block::duplicate (const ACE_Message_Block *mb)
01098 {
01099 ACE_TRACE ("ACE_Message_Block::duplicate");
01100 if (mb == 0)
01101 return 0;
01102 else
01103 return mb->duplicate ();
01104 }
01105
01106 ACE_Data_Block *
01107 ACE_Data_Block::clone (ACE_Message_Block::Message_Flags mask) const
01108 {
01109 ACE_TRACE ("ACE_Data_Block::clone");
01110
01111 ACE_Data_Block *nb = this->clone_nocopy (mask);
01112
01113
01114
01115
01116
01117 if (nb != 0)
01118 {
01119 ACE_OS::memcpy (nb->base_,
01120 this->base_,
01121 this->cur_size_);
01122 }
01123
01124 return nb;
01125 }
01126
01127 ACE_Data_Block *
01128 ACE_Data_Block::clone_nocopy (ACE_Message_Block::Message_Flags mask,
01129 size_t max_size) const
01130 {
01131 ACE_FUNCTION_TIMEPROBE(ACE_DATA_BLOCK_CLONE_ENTER);
01132
01133 ACE_TRACE ("ACE_Data_Block::clone_nocopy");
01134
01135
01136
01137 const ACE_Message_Block::Message_Flags always_clear =
01138 ACE_Message_Block::DONT_DELETE;
01139
01140 const size_t newsize =
01141 max_size == 0 ? this->max_size_ : max_size;
01142
01143 ACE_Data_Block *nb = 0;
01144
01145 ACE_NEW_MALLOC_RETURN (nb,
01146 static_cast<ACE_Data_Block*> (
01147 this->data_block_allocator_->malloc (sizeof (ACE_Data_Block))),
01148 ACE_Data_Block (newsize,
01149 this->type_,
01150 0,
01151 this->allocator_strategy_,
01152 this->locking_strategy_,
01153 this->flags_,
01154 this->data_block_allocator_),
01155 0);
01156
01157
01158
01159
01160 if (nb != 0 && nb->size () < newsize)
01161 {
01162 nb->ACE_Data_Block::~ACE_Data_Block();
01163 this->data_block_allocator_->free (nb);
01164 errno = ENOMEM;
01165 return 0;
01166 }
01167
01168
01169
01170 nb->clr_flags (mask | always_clear);
01171 return nb;
01172 }
01173
01174 ACE_Message_Block *
01175 ACE_Message_Block::clone (Message_Flags mask) const
01176 {
01177 ACE_TRACE ("ACE_Message_Block::clone");
01178
01179
01180
01181 ACE_Data_Block *db = this->data_block ()->clone (mask);
01182
01183 if (db == 0)
01184 return 0;
01185
01186 ACE_Message_Block *nb = 0;
01187
01188 if(message_block_allocator_ == 0)
01189 {
01190 ACE_NEW_RETURN (nb,
01191 ACE_Message_Block (0,
01192 ACE_Message_Type (0),
01193 0,
01194 0,
01195 0,
01196 0,
01197 0,
01198 this->priority_,
01199 ACE_EXECUTION_TIME,
01200 ACE_DEADLINE_TIME,
01201
01202
01203
01204
01205 db,
01206 db->data_block_allocator (),
01207 this->message_block_allocator_),
01208 0);
01209 }
01210 else
01211 {
01212
01213
01214
01215
01216
01217 nb = static_cast<ACE_Message_Block*> (message_block_allocator_->malloc (sizeof (ACE_Message_Block)));
01218 if(nb != 0)
01219 new (nb) ACE_Message_Block (0,
01220 ACE_Message_Type (0),
01221 0,
01222 0,
01223 0,
01224 0,
01225 0,
01226 this->priority_,
01227 ACE_EXECUTION_TIME,
01228 ACE_DEADLINE_TIME,
01229 db,
01230 db->data_block_allocator (),
01231 this->message_block_allocator_);
01232 }
01233
01234 if (nb == 0)
01235 {
01236 db->release ();
01237 return 0;
01238 }
01239
01240
01241
01242 nb->rd_ptr (this->rd_ptr_);
01243 nb->wr_ptr (this->wr_ptr_);
01244
01245
01246 if (this->cont () != 0
01247 && (nb->cont_ = this->cont ()->clone (mask)) == 0)
01248 {
01249 nb->release ();
01250 return 0;
01251 }
01252 return nb;
01253 }
01254
01255
01256 ACE_Message_Block &
01257 ACE_Message_Block::operator= (const ACE_Message_Block &)
01258 {
01259 ACE_TRACE ("ACE_Message_Block::operator=");
01260 return *this;
01261 }
01262
01263 void
01264 ACE_Data_Block::base (char *msg_data,
01265 size_t msg_length,
01266 ACE_Message_Block::Message_Flags msg_flags)
01267 {
01268 if (ACE_BIT_DISABLED (this->flags_,
01269 ACE_Message_Block::DONT_DELETE))
01270 this->allocator_strategy_->free (this->base_);
01271
01272 this->max_size_ = msg_length;
01273 this->cur_size_ = msg_length;
01274 this->base_ = msg_data;
01275 this->flags_ = msg_flags;
01276 }
01277
01278 ACE_END_VERSIONED_NAMESPACE_DECL