ACE  6.4.1
Public Member Functions | Protected Member Functions | Protected Attributes | Private Member Functions | List of all members
ACE_Guard< ACE_LOCK > Class Template Reference

This data structure is meant to be used within a method or function... It performs automatic acquisition and release of a parameterized synchronization object ACE_LOCK. More...

#include <Guard_T.h>

Inheritance diagram for ACE_Guard< ACE_LOCK >:
Inheritance graph
[legend]

Public Member Functions

 ACE_Guard (ACE_LOCK &l)
 
 ACE_Guard (ACE_LOCK &l, bool block)
 
 ACE_Guard (ACE_LOCK &l, bool block, int become_owner)
 
 ~ACE_Guard (void)
 Implicitly release the lock. More...
 
int acquire (void)
 Explicitly acquire the lock. More...
 
int tryacquire (void)
 Conditionally acquire the lock (i.e., won't block). More...
 
int release (void)
 Explicitly release the lock, but only if it is held! More...
 
void disown (void)
 
bool locked (void) const
 
int remove (void)
 Explicitly remove the lock. More...
 
void dump (void) const
 Dump the state of an object. More...
 

Protected Member Functions

 ACE_Guard (ACE_LOCK *lock)
 Helper, meant for subclass only. More...
 

Protected Attributes

ACE_LOCK * lock_
 Pointer to the ACE_LOCK we're guarding. More...
 
int owner_
 Keeps track of whether we acquired the lock or failed. More...
 

Private Member Functions

void operator= (const ACE_Guard< ACE_LOCK > &)
 
 ACE_Guard (const ACE_Guard< ACE_LOCK > &)
 

Detailed Description

template<class ACE_LOCK>
class ACE_Guard< ACE_LOCK >

This data structure is meant to be used within a method or function... It performs automatic acquisition and release of a parameterized synchronization object ACE_LOCK.

The ACE_LOCK class given as an actual parameter must provide, at the very least the acquire(), tryacquire(), release(), and remove() methods.

Warning
A successfully constructed ACE_Guard does NOT mean that the lock was acquired! It is the caller's responsibility, after constructing an ACE_Guard, to check whether the lock was successfully acquired. Code like this is dangerous: { ACE_Guard<ACE_Lock> g(lock); ... perform critical operation requiring lock to be held ... } Instead, one must do something like this: { ACE_Guard<ACE_Lock> g(lock); if (! g.locked()) { ... handle error ... } else { ... perform critical operation requiring lock to be held ... } } The ACE_GUARD_RETURN() and ACE_GUARD_REACTION() macros are designed to to help with this.

Constructor & Destructor Documentation

template<class ACE_LOCK >
ACE_Guard< ACE_LOCK >::ACE_Guard ( ACE_LOCK &  l)
inline
template<class ACE_LOCK >
ACE_Guard< ACE_LOCK >::ACE_Guard ( ACE_LOCK &  l,
bool  block 
)
inline

Implicitly and automatically acquire (or try to acquire) the lock. If block is non-0 then acquire() the ACE_LOCK, else tryacquire() it.

template<class ACE_LOCK >
ACE_Guard< ACE_LOCK >::ACE_Guard ( ACE_LOCK &  l,
bool  block,
int  become_owner 
)
inline

Initialize the guard without implicitly acquiring the lock. The become_owner parameter indicates whether the guard should release the lock implicitly on destruction. The block parameter is ignored and is used here to disambiguate with the preceding constructor.

template<class ACE_LOCK >
ACE_Guard< ACE_LOCK >::~ACE_Guard ( void  )
inline

Implicitly release the lock.

template<class ACE_LOCK>
ACE_Guard< ACE_LOCK >::ACE_Guard ( ACE_LOCK *  lock)
inlineprotected

Helper, meant for subclass only.

template<class ACE_LOCK>
ACE_Guard< ACE_LOCK >::ACE_Guard ( const ACE_Guard< ACE_LOCK > &  )
private

Member Function Documentation

template<class ACE_LOCK >
int ACE_Guard< ACE_LOCK >::acquire ( void  )
inline

Explicitly acquire the lock.

template<class ACE_LOCK >
void ACE_Guard< ACE_LOCK >::disown ( void  )
inline

Relinquish ownership of the lock so that it is not released implicitly in the destructor.

template<class ACE_LOCK >
void ACE_Guard< ACE_LOCK >::dump ( void  ) const

Dump the state of an object.

template<class ACE_LOCK >
bool ACE_Guard< ACE_LOCK >::locked ( void  ) const
inline

true if locked, false if couldn't acquire the lock (errno will contain the reason for this).

template<class ACE_LOCK>
void ACE_Guard< ACE_LOCK >::operator= ( const ACE_Guard< ACE_LOCK > &  )
private
template<class ACE_LOCK >
int ACE_Guard< ACE_LOCK >::release ( void  )
inline

Explicitly release the lock, but only if it is held!

template<class ACE_LOCK >
int ACE_Guard< ACE_LOCK >::remove ( void  )
inline

Explicitly remove the lock.

template<class ACE_LOCK >
int ACE_Guard< ACE_LOCK >::tryacquire ( void  )
inline

Conditionally acquire the lock (i.e., won't block).

Member Data Documentation

template<class ACE_LOCK>
ACE_LOCK* ACE_Guard< ACE_LOCK >::lock_
protected

Pointer to the ACE_LOCK we're guarding.

template<class ACE_LOCK>
int ACE_Guard< ACE_LOCK >::owner_
protected

Keeps track of whether we acquired the lock or failed.


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