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, size_t max_size=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,
size_t  max_size = 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(). 

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

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 66 of file Message_Block_T.h.

The documentation for this class was generated from the following files:
Generated on Sun Jan 27 12:55:19 2008 for ACE by doxygen 1.3.6