Main Page | Namespace List | Class Hierarchy | Alphabetical List | Class List | File List | Namespace Members | Class Members | File Members | Related Pages | Search for 

ACE_Locked_Data_Block< ACE_LOCK > Class Template Reference

A Data_Block with a concrete locking strategy. More...

#include <Message_Block_T.h>

Inheritance diagram for ACE_Locked_Data_Block< ACE_LOCK >:

Inheritance graph
[legend]
Collaboration diagram for ACE_Locked_Data_Block< ACE_LOCK >:

Collaboration graph
[legend]
List of all members.

Public Member Functions

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

 ACE_Locked_Data_Block (size_t size, ACE_Message_Block::ACE_Message_Type msg_type, const char *msg_data, ACE_Allocator *allocator_strategy, ACE_Message_Block::Message_Flags flags, ACE_Allocator *data_block_allocator)
 Initialize.

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

virtual ACE_Data_Block * clone_nocopy (ACE_Message_Block::Message_Flags mask=0) const

Private Member Functions

ACE_Locked_Data_Block< ACE_LOCK > & operator= (const ACE_Locked_Data_Block< ACE_LOCK > &)
 ACE_Locked_Data_Block (const ACE_Locked_Data_Block< ACE_LOCK > &)

Private Attributes

ACE_LOCK lock_
 The lock.

Detailed Description

template<class ACE_LOCK>
class ACE_Locked_Data_Block< ACE_LOCK >

A Data_Block with a concrete locking strategy.

Data_Blocks can be parametric on the kind of lock they use; in many cases the lifetime of the lock is tied to the lifetime of the Data_Block itself. But since Data_Blocks are reference counted it is hard for users to control the lock lifetime. This class is parametric over the kind of lock used.

Definition at line 38 of file Message_Block_T.h.

Constructor & Destructor Documentation

template<class ACE_LOCK>
ACE_BEGIN_VERSIONED_NAMESPACE_DECL ACE_INLINE ACE_Locked_Data_Block< ACE_LOCK >::ACE_Locked_Data_Block (  void   ) 
 

Default "do-nothing" constructor.

Definition at line 8 of file Message_Block_T.inl. 

00009 {
00010   this->locking_strategy_ = &this->lock_;
00011 }

template<class ACE_LOCK>
ACE_INLINE ACE_Locked_Data_Block< ACE_LOCK >::ACE_Locked_Data_Block (  size_t  size,
ACE_Message_Block::ACE_Message_Type  msg_type,
const char *  msg_data,
ACE_Allocator *  allocator_strategy,
ACE_Message_Block::Message_Flags  flags,
ACE_Allocator *  data_block_allocator
) 
 

Initialize.

Definition at line 15 of file Message_Block_T.inl.

References ACE_Message_Block::ACE_Message_Type, and ACE_Message_Block::Message_Flags. 

00021   : ACE_Data_Block (size,
00022                     msg_type,
00023                     msg_data,
00024                     allocator_strategy,
00025                     &lock_,
00026                     flags,
00027                     data_block_allocator)
00028 {
00029 }

template<class L>
ACE_BEGIN_VERSIONED_NAMESPACE_DECL ACE_Locked_Data_Block< L >::~ACE_Locked_Data_Block (  void   )  [virtual]
 

Delete all the resources held in the message.

Definition at line 17 of file Message_Block_T.cpp. 

00018 {
00019 }

template<class ACE_LOCK>
ACE_Locked_Data_Block< ACE_LOCK >::ACE_Locked_Data_Block (  const ACE_Locked_Data_Block< ACE_LOCK > &   )  [private]
 

Member Function Documentation

template<class ACE_LOCK>
ACE_Data_Block * ACE_Locked_Data_Block< ACE_LOCK >::clone_nocopy (  ACE_Message_Block::Message_Flags  mask = 0  )  const [virtual]
 

Return an exact "deep copy" of the message, the dynamic type is ACE_Locked_Data_Block<> See the documentation in Message_Block.h for details.

Reimplemented from ACE_Data_Block.

Definition at line 22 of file Message_Block_T.cpp.

References ACE_NEW_MALLOC_RETURN, ACE_TRACE, ACE_Data_Block::allocator_strategy(), ACE_Data_Block::clr_flags(), ACE_Data_Block::data_block_allocator(), ACE_Data_Block::flags(), ACE_Message_Block::Message_Flags, ACE_Data_Block::msg_type(), and ACE_Data_Block::size(). 

00023 {
00024   ACE_TRACE ("ACE_Locked_Data_Block::clone_nocopy");
00025 
00026   // You always want to clear this one to prevent memory leaks but you
00027   // might add some others later.
00028   const ACE_Message_Block::Message_Flags always_clear =
00029     ACE_Message_Block::DONT_DELETE;
00030 
00031   ACE_Locked_Data_Block<ACE_LOCK> *nb = 0;
00032 
00033   ACE_NEW_MALLOC_RETURN (nb,
00034                          static_cast<ACE_Locked_Data_Block<ACE_LOCK>*> (
00035                                          this->data_block_allocator ()->malloc (sizeof (ACE_Locked_Data_Block<ACE_LOCK>))),
00036                          ACE_Locked_Data_Block<ACE_LOCK> (this->size (),
00037                                                    this->msg_type (),
00038                                                    0,
00039                                                    this->allocator_strategy (),
00040                                                    this->flags (),
00041                                                    this->data_block_allocator ()),
00042                          0);
00043 
00044   // Set new flags minus the mask...
00045   nb->clr_flags (mask | always_clear);
00046   return nb;
00047 }

template<class ACE_LOCK>
ACE_Locked_Data_Block<ACE_LOCK>& ACE_Locked_Data_Block< ACE_LOCK >::operator= (  const ACE_Locked_Data_Block< ACE_LOCK > &   )  [private]
 

Member Data Documentation

template<class ACE_LOCK>
ACE_LOCK ACE_Locked_Data_Block< ACE_LOCK >::lock_ [private]
 

The lock.

Definition at line 65 of file Message_Block_T.h.

The documentation for this class was generated from the following files:
Generated on Thu Nov 9 11:23:52 2006 for ACE by doxygen 1.3.6