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

ACE_Data_Block Class Reference

Stores the data payload that is accessed via one or more <ACE_Message_Block>s. More...

#include <Message_Block.h>

Inheritance diagram for ACE_Data_Block:

Inheritance graph
Collaboration diagram for ACE_Data_Block:

Collaboration graph
List of all members.

Public Methods

 ACE_Data_Block (void)
 Default "do-nothing" constructor.

 ACE_Data_Block (size_t size, ACE_Message_Block::ACE_Message_Type msg_type, const char *msg_data, ACE_Allocator *allocator_strategy, ACE_Lock *locking_strategy, ACE_Message_Block::Message_Flags flags, ACE_Allocator *data_block_allocator)

virtual ~ACE_Data_Block (void)
 Delete all the resources held in the message.

ACE_Message_Block::ACE_Message_Type msg_type (void) const
 Get type of the message.

void msg_type (ACE_Message_Block::ACE_Message_Type type)
 Set type of the message.

char * base (void) const
 Get message data pointer.

void base (char *data, size_t size, ACE_Message_Block::Message_Flags mflags=ACE_Message_Block::DONT_DELETE)
 Set message data pointer (doesn't reallocate).

char * end (void) const
 Return a pointer to 1 past the end of the allocated data in a message.

char * mark (void) const
size_t size (void) const
int size (size_t length)
size_t capacity (void) const
 Get the total amount of allocated space.

virtual ACE_Data_Block * clone (ACE_Message_Block::Message_Flags mask=0) const
virtual ACE_Data_Block * clone_nocopy (ACE_Message_Block::Message_Flags mask=0) const
ACE_Data_Block * duplicate (void)
 Return a "shallow" copy that increments our reference count by 1.

ACE_Data_Block * release (ACE_Lock *lock=0)
ACE_Message_Block::Message_Flags set_flags (ACE_Message_Block::Message_Flags more_flags)
ACE_Message_Block::Message_Flags clr_flags (ACE_Message_Block::Message_Flags less_flags)
ACE_Message_Block::Message_Flags flags (void) const
 Get the current message flags.

ACE_Allocatorallocator_strategy (void) const
 Obtain the allocator strategy.

ACE_Locklocking_strategy (void)
 Get the locking strategy.

ACE_Locklocking_strategy (ACE_Lock *)
 Set a new locking strategy and return the hold one.

void dump (void) const
 Dump the state of an object.

int reference_count (void) const
 Get the current reference count.

ACE_Allocatordata_block_allocator (void) const
 Get the allocator used to create this object.

Protected Methods

ACE_Data_Block * release_i (void)
 Internal release implementation.

ACE_Data_Block * release_no_delete (ACE_Lock *lock)

Protected Attributes

ACE_Message_Block::ACE_Message_Type type_
 Type of message.

size_t cur_size_
 Current size of message block.

size_t max_size_
 Total size of buffer.

ACE_Message_Block::Message_Flags flags_
 Misc flags (e.g., DONT_DELETE and USER_FLAGS).

char * base_
 Pointer To beginning of message payload.

int reference_count_
 The allocator use to destroy ourselves.

Private Methods

ACE_Data_Block & operator= (const ACE_Data_Block &)
 ACE_Data_Block (const ACE_Data_Block &)


class ACE_Message_Block

Detailed Description

Stores the data payload that is accessed via one or more <ACE_Message_Block>s.

This data structure is reference counted to maximize sharing. It also contains the <locking_strategy_> (which protects the reference count from race conditions in concurrent programs) and the <allocation_strategy_> (which determines what memory pool is used to allocate the memory).

Constructor & Destructor Documentation

ACE_Data_Block::ACE_Data_Block void   

Default "do-nothing" constructor.

ACE_Data_Block::ACE_Data_Block size_t    size,
ACE_Message_Block::ACE_Message_Type    msg_type,
const char *    msg_data,
ACE_Allocator   allocator_strategy,
ACE_Lock   locking_strategy,
ACE_Message_Block::Message_Flags    flags,
ACE_Allocator   data_block_allocator


ACE_Data_Block::~ACE_Data_Block void    [virtual]

Delete all the resources held in the message.

ACE_Data_Block::ACE_Data_Block const ACE_Data_Block &    [private]

Member Function Documentation

ACE_INLINE ACE_Allocator * ACE_Data_Block::allocator_strategy void    const

Obtain the allocator strategy.

void ACE_Data_Block::base char *    data,
size_t    size,
ACE_Message_Block::Message_Flags    mflags = ACE_Message_Block::DONT_DELETE

Set message data pointer (doesn't reallocate).

ACE_INLINE char * ACE_Data_Block::base void    const

Get message data pointer.

ACE_INLINE size_t ACE_Data_Block::capacity void    const

Get the total amount of allocated space.

ACE_Data_Block * ACE_Data_Block::clone ACE_Message_Block::Message_Flags    mask = 0 const [virtual]

Return an exact "deep copy" of the message, i.e., create fresh new copies of all the Data_Blocks and continuations. Notice that Data_Blocks can act as "Prototypes", i.e. derived classes can override this method and create instances of themselves.

ACE_Data_Block * ACE_Data_Block::clone_nocopy ACE_Message_Block::Message_Flags    mask = 0 const [virtual]

As clone above, but it does not copy the contents of the buffer, i.e., create a new Data_Block of the same dynamic type, with the same allocator, locking_strategy, and with the same amount of storage available but the buffer is unitialized.

Reimplemented in ACE_Locked_Data_Block< ACE_LOCK >.

ACE_INLINE ACE_Message_Block::Message_Flags ACE_Data_Block::clr_flags ACE_Message_Block::Message_Flags    less_flags

Clear the message flag bits specified in <less_flags> and return the new value.

ACE_INLINE ACE_Allocator * ACE_Data_Block::data_block_allocator void    const

Get the allocator used to create this object.

void ACE_Data_Block::dump void    const

Dump the state of an object.

ACE_Data_Block * ACE_Data_Block::duplicate void   

Return a "shallow" copy that increments our reference count by 1.

ACE_INLINE char * ACE_Data_Block::end void    const

Return a pointer to 1 past the end of the allocated data in a message.

ACE_INLINE ACE_Message_Block::Message_Flags ACE_Data_Block::flags void    const

Get the current message flags.

ACE_INLINE ACE_Lock * ACE_Data_Block::locking_strategy ACE_Lock  

Set a new locking strategy and return the hold one.

ACE_INLINE ACE_Lock * ACE_Data_Block::locking_strategy void   

Get the locking strategy.

ACE_INLINE char * ACE_Data_Block::mark void    const

Return a pointer to 1 past the end of the allotted data in a message. The allotted data may be less than allocated data if <size()> is passed an argument less than <capacity()>.

ACE_INLINE void ACE_Data_Block::msg_type ACE_Message_Block::ACE_Message_Type    type

Set type of the message.

ACE_INLINE ACE_Message_Block::ACE_Message_Type ACE_Data_Block::msg_type void    const

Get type of the message.

ACE_Data_Block& ACE_Data_Block::operator= const ACE_Data_Block &    [private]

ACE_INLINE int ACE_Data_Block::reference_count void    const

Get the current reference count.

ACE_Data_Block * ACE_Data_Block::release ACE_Lock   lock = 0

Decrease the shared reference count by 1. If the reference count is > 0 then return this; else if reference count == 0 then delete <this> and <mb> and return 0. Behavior is undefined if reference count < 0.

ACE_Data_Block * ACE_Data_Block::release_i void    [protected]

Internal release implementation.

ACE_Data_Block * ACE_Data_Block::release_no_delete ACE_Lock   lock [protected]

ACE_INLINE ACE_Message_Block::Message_Flags ACE_Data_Block::set_flags ACE_Message_Block::Message_Flags    more_flags

Bitwise-or the <more_flags> into the existing message flags and return the new value.

int ACE_Data_Block::size size_t    length

Set the total amount of space in the message. Returns 0 if successful, else -1.

ACE_INLINE size_t ACE_Data_Block::size void    const

Get the total amount of allotted space in the message. The amount of allotted space may be less than allocated space.

Friends And Related Function Documentation

friend class ACE_Message_Block [friend]

Decrease the reference count, but don't delete the object. Returns 0 if the object should be removed. If <lock> is equal to the locking strategy then we assume that the lock is beign held by the current thread; this is used to release all the data blocks in a chain while holding a single lock.

Member Data Documentation

ACE_Allocator* ACE_Data_Block::allocator_strategy_ [protected]

Pointer to the allocator defined for this <ACE_Data_Block>. Note that this pointer is shared by all owners of this <ACE_Data_Block>.

char* ACE_Data_Block::base_ [protected]

Pointer To beginning of message payload.

size_t ACE_Data_Block::cur_size_ [protected]

Current size of message block.

ACE_Allocator* ACE_Data_Block::data_block_allocator_ [protected]

The allocator use to destroy ourselves.

ACE_Message_Block::Message_Flags ACE_Data_Block::flags_ [protected]

Misc flags (e.g., DONT_DELETE and USER_FLAGS).

ACE_Lock* ACE_Data_Block::locking_strategy_ [protected]

Pointer to the locking strategy defined for this <ACE_Data_Block>. This is used to protect regions of code that access shared <ACE_Data_Block> state. Note that this lock is shared by all owners of the <ACE_Data_Block>'s data.

size_t ACE_Data_Block::max_size_ [protected]

Total size of buffer.

int ACE_Data_Block::reference_count_ [protected]

Reference count for this <ACE_Data_Block>, which is used to avoid deep copies (i.e., <clone>). Note that this pointer value is shared by all owners of the <Data_Block>'s data, i.e., all the <ACE_Message_Block>s.

ACE_Message_Block::ACE_Message_Type ACE_Data_Block::type_ [protected]

Type of message.

The documentation for this class was generated from the following files:
Generated on Fri Apr 2 16:47:51 2004 for ACE by doxygen1.2.18