josh/TCPlayerbotCore
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

*Backed out changeset 3be01fb200a5

Browse Source 
--HG--
branch : trunk
This commit is contained in:
maximius
2009-10-17 15:51:44 -07:00
parent 26b5e033ff
commit e585187b24
2257 changed files with 103863 additions and 761 deletions
Download Patch File Download Diff File Expand all files Collapse all files
dep/ACE_wrappers/ace/Message_Block.cpp
+170
View File
@@ -1,19 +1,27 @@
#include "ace/Message_Block.h"
#if !defined (__ACE_INLINE__)
#include "ace/Message_Block.inl"
#endif /* __ACE_INLINE__ */
#include "ace/Guard_T.h"
#include "ace/Log_Msg.h"
#include "ace/Malloc_Base.h"
#include "ace/OS_NS_string.h"
//#define ACE_ENABLE_TIMEPROBES
#include "ace/Timeprobe.h"
ACE_RCSID (ace,
Message_Block,
"$Id: Message_Block.cpp 80826 2008-03-04 14:51:23Z wotte $")
ACE_BEGIN_VERSIONED_NAMESPACE_DECL
ACE_ALLOC_HOOK_DEFINE (ACE_Message_Block)
#if defined (ACE_ENABLE_TIMEPROBES)
static const char *ACE_MB_Timeprobe_Description[] =
{
"Message_Block::init_i - enter",
@@ -27,6 +35,7 @@ static const char *ACE_MB_Timeprobe_Description[] =
"Data_Block::clone - enter",
"Data_Block::clone - leave"
};
enum
{
ACE_MESSAGE_BLOCK_INIT_I_ENTER = 3000,
@@ -41,10 +50,13 @@ enum
ACE_DATA_BLOCK_CLONE_LEAVE
};
// Setup Timeprobes
ACE_TIMEPROBE_EVENT_DESCRIPTIONS (ACE_MB_Timeprobe_Description,
ACE_MESSAGE_BLOCK_INIT_I_ENTER);
#endif /* ACE_ENABLE_TIMEPROBES */
void
ACE_Message_Block::data_block (ACE_Data_Block *db)
{
@@ -53,19 +65,24 @@ ACE_Message_Block::data_block (ACE_Data_Block *db)
ACE_Message_Block::DONT_DELETE)
&& this->data_block_ != 0)
this->data_block_->release ();
this->data_block_ = db;
// Set the read and write pointers in the <Message_Block> to point
// to the buffer in the <ACE_Data_Block>.
this->rd_ptr (this->data_block ()->base ());
this->wr_ptr (this->data_block ()->base ());
}
int
ACE_Message_Block::copy (const char *buf, size_t n)
{
ACE_TRACE ("ACE_Message_Block::copy");
/*size_t len = static_cast<size_t> (this->end () - this->wr_ptr ());*/
// Note that for this to work correct, end () *must* be >= mark ().
size_t len = this->space ();
if (len < n)
{
errno = ENOSPC;
@@ -80,14 +97,18 @@ ACE_Message_Block::copy (const char *buf, size_t n)
return 0;
}
}
int
ACE_Message_Block::copy (const char *buf)
{
ACE_TRACE ("ACE_Message_Block::copy");
/* size_t len = static_cast<size_t> (this->end () - this->wr_ptr ()); */
// Note that for this to work correct, end() *must* be >= wr_ptr().
size_t len = this->space ();
size_t buflen = ACE_OS::strlen (buf) + 1;
if (len < buflen)
{
errno = ENOSPC;
@@ -102,6 +123,7 @@ ACE_Message_Block::copy (const char *buf)
return 0;
}
}
int
ACE_Message_Block::crunch (void)
{
@@ -109,6 +131,7 @@ ACE_Message_Block::crunch (void)
{
if (this->rd_ptr_ > this->wr_ptr_)
return -1;
size_t const len = this->length ();
(void) ACE_OS::memmove (this->base (),
this->rd_ptr (),
@@ -118,6 +141,7 @@ ACE_Message_Block::crunch (void)
}
return 0;
}
void
ACE_Data_Block::dump (void) const
{
@@ -145,6 +169,7 @@ ACE_Data_Block::dump (void) const
ACE_DEBUG ((LM_DEBUG, ACE_END_DUMP));
#endif /* ACE_HAS_DUMP */
}
void
ACE_Message_Block::dump (void) const
{
@@ -170,6 +195,7 @@ ACE_Message_Block::dump (void) const
ACE_DEBUG ((LM_DEBUG, ACE_END_DUMP));
#endif /* ACE_HAS_DUMP */
}
int
ACE_Data_Block::reference_count (void) const
{
@@ -177,14 +203,18 @@ ACE_Data_Block::reference_count (void) const
{
// We need to acquire the lock before retrieving the count
ACE_GUARD_RETURN (ACE_Lock, ace_mon, *this->locking_strategy_, 0);
return this->reference_count_i ();
}
return this->reference_count_i ();
}
int
ACE_Data_Block::size (size_t length)
{
ACE_TRACE ("ACE_Data_Block::size");
if (length <= this->max_size_)
this->cur_size_ = length;
else
@@ -194,6 +224,7 @@ ACE_Data_Block::size (size_t length)
ACE_ALLOCATOR_RETURN (buf,
(char *) this->allocator_strategy_->malloc (length),
-1);
ACE_OS::memcpy (buf,
this->base_,
this->cur_size_);
@@ -210,20 +241,25 @@ ACE_Data_Block::size (size_t length)
}
return 0;
}
int
ACE_Message_Block::size (size_t length)
{
ACE_TRACE ("ACE_Message_Block::size");
// Resize the underlying <ACE_Data_Block>.
if (this->data_block ()->size (length) == -1)
return -1;
return 0;
}
void
ACE_Message_Block::total_size_and_length (size_t &mb_size,
size_t &mb_length) const
{
ACE_TRACE ("ACE_Message_Block::total_size_and_length");
for (const ACE_Message_Block *i = this;
i != 0;
i = i->cont ())
@@ -232,39 +268,50 @@ ACE_Message_Block::total_size_and_length (size_t &mb_size,
mb_length += i->length ();
}
}
size_t
ACE_Message_Block::total_size (void) const
{
ACE_TRACE ("ACE_Message_Block::total_size");
size_t size = 0;
for (const ACE_Message_Block *i = this;
i != 0;
i = i->cont ())
size += i->size ();
return size;
}
size_t
ACE_Message_Block::total_length (void) const
{
ACE_TRACE ("ACE_Message_Block::total_length");
size_t length = 0;
for (const ACE_Message_Block *i = this;
i != 0;
i = i->cont ())
length += i->length ();
return length;
}
size_t
ACE_Message_Block::total_capacity (void) const
{
ACE_TRACE ("ACE_Message_Block::total_capacity");
size_t size = 0;
for (const ACE_Message_Block *i = this;
i != 0;
i = i->cont ())
size += i->capacity ();
return size;
}
ACE_Data_Block::ACE_Data_Block (void)
: type_ (ACE_Message_Block::MB_DATA),
cur_size_ (0),
@@ -278,11 +325,14 @@ ACE_Data_Block::ACE_Data_Block (void)
{
ACE_TRACE ("ACE_Data_Block::ACE_Data_Block");
ACE_FUNCTION_TIMEPROBE (ACE_DATA_BLOCK_CTOR1_ENTER);
ACE_ALLOCATOR (this->allocator_strategy_,
ACE_Allocator::instance ());
ACE_ALLOCATOR (this->data_block_allocator_,
ACE_Allocator::instance ());
}
ACE_Data_Block::ACE_Data_Block (size_t size,
ACE_Message_Block::ACE_Message_Type msg_type,
const char *msg_data,
@@ -302,14 +352,17 @@ ACE_Data_Block::ACE_Data_Block (size_t size,
{
ACE_TRACE ("ACE_Data_Block::ACE_Data_Block");
ACE_FUNCTION_TIMEPROBE (ACE_DATA_BLOCK_CTOR2_ENTER);
// If the user didn't pass one in, let's use the
// <ACE_Allocator::instance>.
if (this->allocator_strategy_ == 0)
ACE_ALLOCATOR (this->allocator_strategy_,
ACE_Allocator::instance ());
if (this->data_block_allocator_ == 0)
ACE_ALLOCATOR (this->data_block_allocator_,
ACE_Allocator::instance ());
if (msg_data == 0)
{
ACE_ALLOCATOR (this->base_,
@@ -320,16 +373,19 @@ ACE_Data_Block::ACE_Data_Block (size_t size,
size);
#endif /* ACE_INITIALIZE_MEMORY_BEFORE_USE */
}
// ACE_ALLOCATOR returns on alloc failure but we cant throw, so setting
// the size to 0 (i.e. "bad bit") ...
if (this->base_ == 0)
{
size = 0;
}
// The memory is legit, whether passed in or allocated, so set
// the size.
this->cur_size_ = this->max_size_ = size;
}
ACE_Message_Block::ACE_Message_Block (const char *data,
size_t size,
unsigned long priority)
@@ -337,6 +393,7 @@ ACE_Message_Block::ACE_Message_Block (const char *data,
data_block_ (0)
{
ACE_TRACE ("ACE_Message_Block::ACE_Message_Block");
if (this->init_i (size, // size
MB_DATA, // type
0, // cont
@@ -353,11 +410,13 @@ ACE_Message_Block::ACE_Message_Block (const char *data,
ACE_ERROR ((LM_ERROR,
ACE_TEXT ("ACE_Message_Block")));
}
ACE_Message_Block::ACE_Message_Block (ACE_Allocator *message_block_allocator)
: flags_ (0),
data_block_ (0)
{
ACE_TRACE ("ACE_Message_Block::ACE_Message_Block");
if (this->init_i (0, // size
MB_DATA, // type
0, // cont
@@ -374,6 +433,7 @@ ACE_Message_Block::ACE_Message_Block (ACE_Allocator *message_block_allocator)
ACE_ERROR ((LM_ERROR,
ACE_TEXT ("ACE_Message_Block")));
}
ACE_Message_Block::ACE_Message_Block (size_t size,
ACE_Message_Type msg_type,
ACE_Message_Block *msg_cont,
@@ -389,6 +449,7 @@ ACE_Message_Block::ACE_Message_Block (size_t size,
data_block_ (0)
{
ACE_TRACE ("ACE_Message_Block::ACE_Message_Block");
if (this->init_i (size,
msg_type,
msg_cont,
@@ -405,6 +466,7 @@ ACE_Message_Block::ACE_Message_Block (size_t size,
ACE_ERROR ((LM_ERROR,
ACE_TEXT ("ACE_Message_Block")));
}
int
ACE_Message_Block::init (size_t size,
ACE_Message_Type msg_type,
@@ -419,6 +481,7 @@ ACE_Message_Block::init (size_t size,
ACE_Allocator *message_block_allocator)
{
ACE_TRACE ("ACE_Message_Block::init");
return this->init_i (size,
msg_type,
msg_cont,
@@ -433,12 +496,14 @@ ACE_Message_Block::init (size_t size,
data_block_allocator,
message_block_allocator);
}
int
ACE_Message_Block::init (const char *data,
size_t size)
{
ACE_TRACE ("ACE_Message_Block::init");
// Should we also initialize all the other fields, as well?
return this->init_i (size, // size
MB_DATA, // type
0, // cont
@@ -453,6 +518,7 @@ ACE_Message_Block::init (const char *data,
0, // data_block allocator
0); // message_block allocator
}
ACE_Message_Block::ACE_Message_Block (size_t size,
ACE_Message_Type msg_type,
ACE_Message_Block *msg_cont,
@@ -470,6 +536,7 @@ ACE_Message_Block::ACE_Message_Block (size_t size,
data_block_ (0)
{
ACE_TRACE ("ACE_Message_Block::ACE_Message_Block");
if (this->init_i (size,
msg_type,
msg_cont,
@@ -486,6 +553,7 @@ ACE_Message_Block::ACE_Message_Block (size_t size,
ACE_ERROR ((LM_ERROR,
ACE_TEXT ("ACE_Message_Block")));
}
ACE_Message_Block::ACE_Message_Block (ACE_Data_Block *data_block,
ACE_Message_Block::Message_Flags flags,
ACE_Allocator *message_block_allocator)
@@ -493,6 +561,7 @@ ACE_Message_Block::ACE_Message_Block (ACE_Data_Block *data_block,
data_block_ (0)
{
ACE_TRACE ("ACE_Message_Block::ACE_Message_Block");
if (this->init_i (0, // size
MB_NORMAL, // type
0, // cont
@@ -509,12 +578,14 @@ ACE_Message_Block::ACE_Message_Block (ACE_Data_Block *data_block,
ACE_ERROR ((LM_ERROR,
ACE_TEXT ("ACE_Message_Block")));
}
ACE_Message_Block::ACE_Message_Block (const ACE_Message_Block &mb,
size_t align)
:flags_ (0),
data_block_ (0)
{
ACE_TRACE ("ACE_Message_Block::ACE_Message_Block");
if (ACE_BIT_DISABLED (mb.flags_,
ACE_Message_Block::DONT_DELETE))
{
@@ -540,9 +611,11 @@ ACE_Message_Block::ACE_Message_Block (const ACE_Message_Block &mb,
#else
char *start = this->base ();
#endif /* ACE_LACKS_CDR_ALIGNMENT */
// Set our rd & wr pointers
this->rd_ptr (start);
this->wr_ptr (start);
}
else
{
@@ -561,6 +634,7 @@ ACE_Message_Block::ACE_Message_Block (const ACE_Message_Block &mb,
mb.message_block_allocator_) == -1)
ACE_ERROR ((LM_ERROR,
ACE_TEXT ("ACE_Message_Block")));
#if !defined (ACE_LACKS_CDR_ALIGNMENT)
// Align ourselves
char *start = ACE_ptr_align_binary (this->base (),
@@ -568,9 +642,11 @@ ACE_Message_Block::ACE_Message_Block (const ACE_Message_Block &mb,
#else
char *start = this->base ();
#endif /* ACE_LACKS_CDR_ALIGNMENT */
// Set our rd & wr pointers
this->rd_ptr (start);
this->wr_ptr (start);
#if !defined (ACE_LACKS_CDR_ALIGNMENT)
// Get the alignment offset of the incoming ACE_Message_Block
start = ACE_ptr_align_binary (mb.base (),
@@ -578,20 +654,25 @@ ACE_Message_Block::ACE_Message_Block (const ACE_Message_Block &mb,
#else
start = mb.base ();
#endif /* ACE_LACKS_CDR_ALIGNMENT */
// Actual offset for the incoming message block assuming that it
// is also aligned to the same "align" byte
size_t const wr_offset = mb.wr_ptr_ - (start - mb.base ());
// Copy wr_offset amount of data in to <this->data_block>
(void) ACE_OS::memcpy (this->wr_ptr (),
start,
wr_offset);
// Dont move the write pointer, just leave it to the application
// to do what it wants
}
#if defined (ACE_LACKS_CDR_ALIGNMENT)
ACE_UNUSED_ARG (align);
#endif /* ACE_LACKS_CDR_ALIGNMENT */
}
int
ACE_Message_Block::init_i (size_t size,
ACE_Message_Type msg_type,
@@ -609,6 +690,7 @@ ACE_Message_Block::init_i (size_t size,
{
ACE_TRACE ("ACE_Message_Block::init_i");
ACE_FUNCTION_TIMEPROBE (ACE_MESSAGE_BLOCK_INIT_I_ENTER);
this->rd_ptr_ = 0;
this->wr_ptr_ = 0;
this->priority_ = priority;
@@ -622,19 +704,24 @@ ACE_Message_Block::init_i (size_t size,
this->cont_ = msg_cont;
this->next_ = 0;
this->prev_ = 0;
this->message_block_allocator_ = message_block_allocator;
if (this->data_block_ != 0)
{
this->data_block_->release ();
this->data_block_ = 0;
}
if (db == 0)
{
if (data_block_allocator == 0)
ACE_ALLOCATOR_RETURN (data_block_allocator,
ACE_Allocator::instance (),
-1);
ACE_TIMEPROBE (ACE_MESSAGE_BLOCK_INIT_I_DB_ALLOC);
// Allocate the <ACE_Data_Block> portion, which is reference
// counted.
ACE_NEW_MALLOC_RETURN (db,
@@ -649,6 +736,7 @@ ACE_Message_Block::init_i (size_t size,
data_block_allocator),
-1);
ACE_TIMEPROBE (ACE_MESSAGE_BLOCK_INIT_I_DB_CTOR);
// Message block initialization may fail, while the construction
// succeds. Since ACE may throw no exceptions, we have to do a
// separate check and clean up, like this:
@@ -660,16 +748,21 @@ ACE_Message_Block::init_i (size_t size,
return -1;
}
}
// Reset the data_block_ pointer.
this->data_block (db);
return 0;
}
ACE_Data_Block::~ACE_Data_Block (void)
{
// Sanity check...
ACE_ASSERT (this->reference_count_ <= 1);
// Just to be safe...
this->reference_count_ = 0;
if (ACE_BIT_DISABLED (this->flags_,
ACE_Message_Block::DONT_DELETE))
{
@@ -677,27 +770,36 @@ ACE_Data_Block::~ACE_Data_Block (void)
this->base_ = 0;
}
}
ACE_Data_Block *
ACE_Data_Block::release_i (void)
{
ACE_TRACE ("ACE_Data_Block::release_i");
ACE_ASSERT (this->reference_count_ > 0);
ACE_Data_Block *result = 0;
// decrement reference count
--this->reference_count_;
if (this->reference_count_ == 0)
// this will cause deletion of this
result = 0;
else
result = this;
return result;
}
ACE_Data_Block *
ACE_Data_Block::release_no_delete (ACE_Lock *lock)
{
ACE_TRACE ("ACE_Data_Block::release_no_delete");
ACE_Data_Block *result = 0;
ACE_Lock *lock_to_be_used = 0;
// Check if we were passed in a lock
if (lock != 0)
{
@@ -705,6 +807,7 @@ ACE_Data_Block::release_no_delete (ACE_Lock *lock)
if (lock == this->locking_strategy_)
// In this case no locking is required.
lock_to_be_used = 0;
// The lock passed in does not match our lock
else
// Lock to be used is our lock
@@ -714,23 +817,30 @@ ACE_Data_Block::release_no_delete (ACE_Lock *lock)
else
// Lock to be used is our lock
lock_to_be_used = this->locking_strategy_;
// If there's a locking strategy then we need to acquire the lock
// before decrementing the count.
if (lock_to_be_used != 0)
{
ACE_GUARD_RETURN (ACE_Lock, ace_mon, *lock_to_be_used, 0);
result = this->release_i ();
}
else
result = this->release_i ();
return result;
}
ACE_Data_Block *
ACE_Data_Block::release (ACE_Lock *lock)
{
ACE_TRACE ("ACE_Data_Block::release");
ACE_Allocator *allocator = this->data_block_allocator_;
ACE_Data_Block *result = this->release_no_delete (lock);
// We must delete this outside the scope of the locking_strategy_
// since otherwise we'd be trying to "release" through a deleted
// pointer!
@@ -740,27 +850,34 @@ ACE_Data_Block::release (ACE_Lock *lock)
ACE_Data_Block);
return result;
}
ACE_Message_Block *
ACE_Message_Block::release (void)
{
ACE_TRACE ("ACE_Message_Block::release");
// We want to hold the data block in a temporary variable because we
// invoked "delete this;" at some point, so using this->data_block_
// could be a bad idea.
ACE_Data_Block *tmp = this->data_block ();
// This flag is set to 1 when we have to destroy the data_block
int destroy_dblock = 0;
ACE_Lock *lock = 0;
// Do we have a valid data block
if (this->data_block ())
{
// Grab the lock that belongs to my data block
lock = this->data_block ()->locking_strategy ();
// if we have a lock
if (lock != 0)
{
// One guard for all
ACE_GUARD_RETURN (ACE_Lock, ace_mon, *lock, 0);
// Call non-guarded release with <lock>
destroy_dblock = this->release_i (lock);
}
@@ -772,6 +889,7 @@ ACE_Message_Block::release (void)
else
// This is the case when we don't even have a valid data block
destroy_dblock = this->release_i (0);
if (destroy_dblock != 0)
{
ACE_Allocator *allocator = tmp->data_block_allocator ();
@@ -779,22 +897,27 @@ ACE_Message_Block::release (void)
allocator->free,
ACE_Data_Block);
}
return 0;
}
int
ACE_Message_Block::release_i (ACE_Lock *lock)
{
ACE_TRACE ("ACE_Message_Block::release_i");
// Free up all the continuation messages.
if (this->cont_)
{
ACE_Message_Block *mb = this->cont_;
ACE_Message_Block *tmp = 0;
do
{
tmp = mb;
mb = mb->cont_;
tmp->cont_ = 0;
ACE_Data_Block *db = tmp->data_block ();
if (tmp->release_i (lock) != 0)
{
@@ -805,9 +928,12 @@ ACE_Message_Block::release_i (ACE_Lock *lock)
}
}
while (mb);
this->cont_ = 0;
}
int result = 0;
if (ACE_BIT_DISABLED (this->flags_,
ACE_Message_Block::DONT_DELETE) &&
this->data_block ())
@@ -816,6 +942,7 @@ ACE_Message_Block::release_i (ACE_Lock *lock)
result = 1;
this->data_block_ = 0;
}
// We will now commit suicide: this object *must* have come from the
// allocator given.
if (this->message_block_allocator_ == 0)
@@ -827,31 +954,39 @@ ACE_Message_Block::release_i (ACE_Lock *lock)
allocator->free,
ACE_Message_Block);
}
return result;
}
/* static */ ACE_Message_Block *
ACE_Message_Block::release (ACE_Message_Block *mb)
{
ACE_TRACE ("ACE_Message_Block::release");
if (mb != 0)
return mb->release ();
else
return 0;
}
ACE_Message_Block::~ACE_Message_Block (void)
{
ACE_TRACE ("ACE_Message_Block::~ACE_Message_Block");
if (ACE_BIT_DISABLED (this->flags_,
ACE_Message_Block::DONT_DELETE)&&
this->data_block ())
this->data_block ()->release ();
this->prev_ = 0;
this->next_ = 0;
}
ACE_Data_Block *
ACE_Data_Block::duplicate (void)
{
ACE_TRACE ("ACE_Data_Block::duplicate");
// Create a new <ACE_Message_Block>, but share the <base_> pointer
// data (i.e., don't copy that).
if (this->locking_strategy_)
@@ -862,8 +997,10 @@ ACE_Data_Block::duplicate (void)
}
else
++this->reference_count_;
return this;
}
#if defined (ACE_HAS_TIMED_MESSAGE_BLOCKS)
#define ACE_EXECUTION_TIME this->execution_time_
#define ACE_DEADLINE_TIME this->deadline_time_
@@ -871,14 +1008,18 @@ ACE_Data_Block::duplicate (void)
#define ACE_EXECUTION_TIME ACE_Time_Value::zero
#define ACE_DEADLINE_TIME ACE_Time_Value::max_time
#endif /* ACE_HAS_TIMED_MESSAGE_BLOCKS */
ACE_Message_Block *
ACE_Message_Block::duplicate (void) const
{
ACE_TRACE ("ACE_Message_Block::duplicate");
ACE_Message_Block *nb = 0;
// Create a new <ACE_Message_Block> that contains unique copies of
// the message block fields, but a reference counted duplicate of
// the <ACE_Data_Block>.
// If there is no allocator, use the standard new and delete calls.
if (this->message_block_allocator_ == 0)
ACE_NEW_RETURN (nb,
@@ -922,16 +1063,19 @@ ACE_Message_Block::duplicate (void) const
this->data_block ()->data_block_allocator (),
this->message_block_allocator_),
0);
// Set the read and write pointers in the new <Message_Block> to the
// same relative offset as in the existing <Message_Block>. Note
// that we are assuming that the data_block()->base() pointer
// doesn't change when it's duplicated.
nb->rd_ptr (this->rd_ptr_);
nb->wr_ptr (this->wr_ptr_);
// Increment the reference counts of all the continuation messages.
if (this->cont_)
{
nb->cont_ = this->cont_->duplicate ();
// If things go wrong, release all of our resources and return
// 0.
if (nb->cont_ == 0)
@@ -940,8 +1084,10 @@ ACE_Message_Block::duplicate (void) const
nb = 0;
}
}
return nb;
}
ACE_Message_Block *
ACE_Message_Block::duplicate (const ACE_Message_Block *mb)
{
@@ -951,11 +1097,14 @@ ACE_Message_Block::duplicate (const ACE_Message_Block *mb)
else
return mb->duplicate ();
}
ACE_Data_Block *
ACE_Data_Block::clone (ACE_Message_Block::Message_Flags mask) const
{
ACE_TRACE ("ACE_Data_Block::clone");
ACE_Data_Block *nb = this->clone_nocopy (mask);
// Copy all of the payload memory into the new object. The new block
// was allocated with max_size_ (and, thus, it's cur_size_ is the same
// as max_size_). Maintain the same "has been written" boundary in the
@@ -966,21 +1115,28 @@ ACE_Data_Block::clone (ACE_Message_Block::Message_Flags mask) const
this->base_,
this->cur_size_);
}
return nb;
}
ACE_Data_Block *
ACE_Data_Block::clone_nocopy (ACE_Message_Block::Message_Flags mask,
size_t max_size) const
{
ACE_FUNCTION_TIMEPROBE(ACE_DATA_BLOCK_CLONE_ENTER);
ACE_TRACE ("ACE_Data_Block::clone_nocopy");
// You always want to clear this one to prevent memory leaks but you
// might add some others later.
const ACE_Message_Block::Message_Flags always_clear =
ACE_Message_Block::DONT_DELETE;
const size_t newsize =
max_size == 0 ? this->max_size_ : max_size;
ACE_Data_Block *nb = 0;
ACE_NEW_MALLOC_RETURN (nb,
static_cast<ACE_Data_Block*> (
this->data_block_allocator_->malloc (sizeof (ACE_Data_Block))),
@@ -992,6 +1148,7 @@ ACE_Data_Block::clone_nocopy (ACE_Message_Block::Message_Flags mask,
this->flags_, // flags
this->data_block_allocator_),
0);
// Message block initialization may fail while the construction
// succeds. Since as a matter of policy, ACE may throw no
// exceptions, we have to do a separate check like this.
@@ -1003,20 +1160,26 @@ ACE_Data_Block::clone_nocopy (ACE_Message_Block::Message_Flags mask,
return 0;
}
// Set new flags minus the mask...
nb->clr_flags (mask | always_clear);
return nb;
}
ACE_Message_Block *
ACE_Message_Block::clone (Message_Flags mask) const
{
ACE_TRACE ("ACE_Message_Block::clone");
// Get a pointer to a "cloned" <ACE_Data_Block> (will copy the
// values rather than increment the reference count).
ACE_Data_Block *db = this->data_block ()->clone (mask);
if (db == 0)
return 0;
ACE_Message_Block *nb = 0;
if(message_block_allocator_ == 0)
{
ACE_NEW_RETURN (nb,
@@ -1062,15 +1225,18 @@ ACE_Message_Block::clone (Message_Flags mask) const
db->data_block_allocator (),
this->message_block_allocator_);
}
if (nb == 0)
{
db->release ();
return 0;
}
// Set the read and write pointers in the new <Message_Block> to the
// same relative offset as in the existing <Message_Block>.
nb->rd_ptr (this->rd_ptr_);
nb->wr_ptr (this->wr_ptr_);
// Clone all the continuation messages if necessary.
if (this->cont () != 0
&& (nb->cont_ = this->cont ()->clone (mask)) == 0)
@@ -1080,6 +1246,7 @@ ACE_Message_Block::clone (Message_Flags mask) const
}
return nb;
}
// This is private.
ACE_Message_Block &
ACE_Message_Block::operator= (const ACE_Message_Block &)
@@ -1087,6 +1254,7 @@ ACE_Message_Block::operator= (const ACE_Message_Block &)
ACE_TRACE ("ACE_Message_Block::operator=");
return *this;
}
void
ACE_Data_Block::base (char *msg_data,
size_t msg_length,
@@ -1095,10 +1263,12 @@ ACE_Data_Block::base (char *msg_data,
if (ACE_BIT_DISABLED (this->flags_,
ACE_Message_Block::DONT_DELETE))
this->allocator_strategy_->free (this->base_);
this->max_size_ = msg_length;
this->cur_size_ = msg_length;
this->base_ = msg_data;
this->flags_ = msg_flags;
}
ACE_END_VERSIONED_NAMESPACE_DECL