Main Page | Namespace List | Class Hierarchy | Alphabetical List | Class List | Directories | File List | Namespace Members | Class 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
[legend]
Collaboration diagram for ACE_Data_Block:

Collaboration graph
[legend]
List of all members.

Public Member Functions

 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)
 Initialize.
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_Allocator * allocator_strategy (void) const
 Obtain the allocator strategy.
ACE_Lock * locking_strategy (void)
 Get the locking strategy.
ACE_Lock * locking_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_Allocator * data_block_allocator (void) const
 Get the allocator used to create this object.

Protected Member Functions

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.
ACE_Allocator * allocator_strategy_
ACE_Lock * locking_strategy_
int reference_count_
ACE_Allocator * data_block_allocator_
 The allocator use to destroy ourselves.

Private Member Functions

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 *  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 Dec 31 14:53:41 2004 for ACE by  doxygen 1.3.9.1