Main Page Class Hierarchy Alphabetical List Compound List File List 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:

[legend]
Collaboration diagram for ACE_Data_Block:

[legend]
List of all members.

## Public Methods
| ACE_Data_Block (void)
| Default "do-nothing" constructor. More...
| 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)
| Initialize. More...
virtual | ~ACE_Data_Block (void)
| Delete all the resources held in the message. More...
ACE_Message_Block::ACE_Message_Type | msg_type (void) const
| Get type of the message. More...
void | msg_type (ACE_Message_Block::ACE_Message_Type type)
| Set type of the message. More...
char * | base (void) const
| Get message data pointer. More...
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). More...
char * | end (void) const
| Return a pointer to 1 past the end of the allocated data in a message. More...
char * | mark (void) const
size_t | size (void) const
| Get the total amount of allotted space in the message. The amount of allotted space may be less than allocated space. More...
int | size (size_t length)
| Set the total amount of space in the message. Returns 0 if successful, else -1. More...
size_t | capacity (void) const
| Get the total amount of allocated space. More...
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. More...
ACE_Data_Block * | release (ACE_Lock *lock=0)
ACE_Message_Block::Message_Flags | set_flags (ACE_Message_Block::Message_Flags more_flags)
| Bitwise-or the <more_flags> into the existing message flags and return the new value. More...
ACE_Message_Block::Message_Flags | clr_flags (ACE_Message_Block::Message_Flags less_flags)
| Clear the message flag bits specified in <less_flags> and return the new value. More...
ACE_Message_Block::Message_Flags | flags (void) const
| Get the current message flags. More...
ACE_Allocator * | allocator_strategy (void) const
| Obtain the allocator strategy. More...
ACE_Lock * | locking_strategy (void)
| Get the locking strategy. More...
ACE_Lock * | locking_strategy (ACE_Lock *)
| Set a new locking strategy and return the hold one. More...
void | dump (void) const
| Dump the state of an object. More...
int | reference_count (void) const
| Get the current reference count. More...
ACE_Allocator * | data_block_allocator (void) const
| Get the allocator used to create this object. More...
## Protected Methods
ACE_Data_Block * | release_i (void)
| Internal release implementation. More...
ACE_Data_Block * | release_no_delete (ACE_Lock *lock)
## Protected Attributes
ACE_Message_Block::ACE_Message_Type | type_
| Type of message. More...
size_t | cur_size_
| Current size of message block. More...
size_t | max_size_
| Total size of buffer. More...
ACE_Message_Block::Message_Flags | flags_
| Misc flags (e.g., DONT_DELETE and USER_FLAGS). More...
char * | base_
| Pointer To beginning of message payload. More...
ACE_Allocator * | allocator_strategy_
ACE_Lock * | locking_strategy_
int | reference_count_
ACE_Allocator * | data_block_allocator_
| The allocator use to destroy ourselves. More...
## Private Methods
ACE_Data_Block & | operator= (const ACE_Data_Block &)
| ACE_Data_Block (const ACE_Data_Block &)
## Friends
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
| ) |

| Initialize.

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 * | msg_data,
|  | size_t | msg_length,
|  | ACE_Message_Block::Message_Flags | msg_flags = 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_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 * | nls | ) |

| 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 | t | ) |

| 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:

- Message_Block.h
- Message_Block.cpp
- Message_Block.i