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 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, size_t max_size=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
virtual ACE_Data_Block *	release_i (void)
	Internal release implementation.
int	reference_count_i (void) const
	Internal get the current reference count.
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_Message_Block::ACE_Message_Type ACE_Data_Block::msg_type

(

void

)

const

Get type of the message.

ACE_INLINE void ACE_Data_Block::msg_type

(

ACE_Message_Block::ACE_Message_Type

type

)

Set type of the message.

ACE_INLINE char * ACE_Data_Block::base

(

void

)

const

Get message data pointer.

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

(

void

)

const

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

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

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::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,
		size_t	max_size = 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 (if max_size is zero) but the buffer is unitialized. If max_size is specified other than zero, it will be used when creating the new data block.

Reimplemented in ACE_Locked_Data_Block< ACE_LOCK >.

ACE_Data_Block * ACE_Data_Block::duplicate

(

void

)

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

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_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.

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_Message_Block::Message_Flags ACE_Data_Block::flags

(

void

)

const

Get the current message flags.

ACE_INLINE ACE_Allocator * ACE_Data_Block::allocator_strategy

(

void

)

const

Obtain the allocator strategy.

ACE_INLINE ACE_Lock * ACE_Data_Block::locking_strategy

(

void

)

Get the locking strategy.

ACE_INLINE ACE_Lock * ACE_Data_Block::locking_strategy

(

ACE_Lock *

nls

)

Set a new locking strategy and return the hold one.

void ACE_Data_Block::dump

(

void

)

const

Dump the state of an object.

int ACE_Data_Block::reference_count

(

void

)

const

Get the current reference count.

ACE_INLINE ACE_Allocator * ACE_Data_Block::data_block_allocator

(

void

)

const

Get the allocator used to create this object.

ACE_Data_Block * ACE_Data_Block::release_i

(

void

)

[protected, virtual]

Internal release implementation.

ACE_INLINE int ACE_Data_Block::reference_count_i

(

void

)

const [protected]

Internal get the current reference count.

ACE_Data_Block * ACE_Data_Block::release_no_delete

(

ACE_Lock *

lock

)

[protected]

ACE_Data_Block& ACE_Data_Block::operator=

(

const ACE_Data_Block &

)

[private]

---

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_Message_Block::ACE_Message_Type ACE_Data_Block::type_ [protected]

Type of message.

size_t ACE_Data_Block::cur_size_ [protected]

Current size of message block.

size_t ACE_Data_Block::max_size_ [protected]

Total size of buffer.

ACE_Message_Block::Message_Flags ACE_Data_Block::flags_ [protected]

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

char* ACE_Data_Block::base_ [protected]

Pointer To beginning of message payload.

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.

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.

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_Blocks.

ACE_Allocator* ACE_Data_Block::data_block_allocator_ [protected]

The allocator use to destroy ourselves.

---

The documentation for this class was generated from the following files:

• Message_Block.h
• Message_Block.cpp
• Message_Block.inl