TAO_BEGIN_VERSIONED_NAMESPACE_DECL /*! * @brief Allocate and return a new empty message block of size \a span_size * mimicking parameters of \a mb. * * This function allocates a new aligned message block using the same * allocators and flags as found in \a mb. The size of the new message * block is at least \a span_size; the size may be adjusted up in order * to accomodate alignment requirements and still fit \a span_size bytes * into the aligned buffer. * * @param mb message block whose parameters should be mimicked * @param span_size size of the new message block (will be adjusted for proper * alignment) * @return an aligned message block with rd_ptr sitting at correct * alignment spot, 0 on failure */ static ACE_Message_Block* clone_mb_nocopy_size (ACE_Message_Block *mb, size_t span_size) { // Calculate the required size of the cloned block with alignment size_t const aligned_size = ACE_CDR::first_size (span_size + ACE_CDR::MAX_ALIGNMENT); // Get the allocators ACE_Allocator *data_allocator = 0; ACE_Allocator *data_block_allocator = 0; ACE_Allocator *message_block_allocator = 0; mb->access_allocators (data_allocator, data_block_allocator, message_block_allocator); // Create a new Message Block ACE_Message_Block *nb = 0; ACE_NEW_MALLOC_RETURN (nb, static_cast<ACE_Message_Block*> ( message_block_allocator->malloc ( sizeof (ACE_Message_Block))), ACE_Message_Block(aligned_size, mb->msg_type(), mb->cont(), 0, //we want the data block created data_allocator, mb->locking_strategy(), mb->msg_priority(), mb->msg_execution_time (), mb->msg_deadline_time (), data_block_allocator, message_block_allocator), 0); ACE_CDR::mb_align (nb); // Copy the flags over, but be SURE to clear the DONT_DELETE flag, since // we just dynamically allocated the two things. nb->set_flags (mb->flags()); nb->clr_flags (ACE_Message_Block::DONT_DELETE); return nb; }
// Note: The FooDataWriter gives ownership of the marshalled data // to the WriteDataContainer. ACE_Message_Block* FooDataWriterImpl::marshal( const Foo& instance_data, int for_write) { ACE_Message_Block* mb; if (for_write) { ACE_NEW_MALLOC_RETURN (mb, static_cast<ACE_Message_Block*> ( mb_allocator_->malloc ( sizeof (ACE_Message_Block))), ACE_Message_Block( sizeof (Foo), ACE_Message_Block::MB_DATA, 0, //cont 0, //data foo_allocator_, //allocator_strategy 0, //locking_strategy ACE_DEFAULT_MESSAGE_BLOCK_PRIORITY, ACE_Time_Value::zero, ACE_Time_Value::max_time, db_allocator_, mb_allocator_), 0); mb->copy ((const char *)&instance_data, sizeof (Foo)); } else { // Don't use the cached allocator for the registered sample message // block. Foo* register_sample = new Foo(); *register_sample = instance_data; ACE_NEW_RETURN (mb, ACE_Message_Block ((const char*)register_sample, sizeof (Foo)), 0); // Let the PublicationInstance destructor release the Message Block // and delete this register_sample. mb->clr_flags(ACE_Message_Block::DONT_DELETE); } return mb; }