ACE_Atomic_Op_Ex< ACE_LOCK, TYPE > Class Template Reference

Transparently parameterizes synchronization into basic arithmetic operations. More...

#include <Atomic_Op_T.h>

Collaboration diagram for ACE_Atomic_Op_Ex< ACE_LOCK, TYPE >:

Collaboration graph
[legend]
List of all members.

Public Member Functions

 ACE_Atomic_Op_Ex (ACE_LOCK &mtx)
 Initialize <value_> to 0.
 ACE_Atomic_Op_Ex (ACE_LOCK &mtx, const TYPE &c)
 Initialize <value_> to c.
TYPE operator++ (void)
 Atomically pre-increment <value_>.
TYPE operator++ (int)
 Atomically post-increment <value_>.
TYPE operator+= (const TYPE &rhs)
 Atomically increment <value_> by rhs.
TYPE operator-- (void)
 Atomically pre-decrement <value_>.
TYPE operator-- (int)
 Atomically post-decrement <value_>.
TYPE operator-= (const TYPE &rhs)
 Atomically decrement <value_> by rhs.
bool operator== (const TYPE &rhs) const
 Atomically compare <value_> with rhs.
bool operator!= (const TYPE &rhs) const
 Atomically compare <value_> with rhs.
bool operator>= (const TYPE &rhs) const
 Atomically check if <value_> greater than or equal to rhs.
bool operator> (const TYPE &rhs) const
 Atomically check if <value_> greater than rhs.
bool operator<= (const TYPE &rhs) const
 Atomically check if <value_> less than or equal to rhs.
bool operator< (const TYPE &rhs) const
 Atomically check if <value_> less than rhs.
ACE_Atomic_Op_Ex< ACE_LOCK,
TYPE > & 
operator= (const TYPE &rhs)
 Atomically assign rhs to <value_>.
ACE_Atomic_Op_Ex< ACE_LOCK,
TYPE > & 
operator= (const ACE_Atomic_Op_Ex< ACE_LOCK, TYPE > &rhs)
 Atomically assign <rhs> to <value_>.
TYPE value (void) const
 Explicitly return <value_>.
void dump (void) const
 Dump the state of an object.
 ACE_Atomic_Op_Ex (const ACE_Atomic_Op_Ex< ACE_LOCK, TYPE > &)
 Manage copying...
ACE_LOCK & mutex (void)
TYPE & value_i (void)

Private Attributes

ACE_LOCK & mutex_
 Type of synchronization mechanism.
TYPE value_
 Current object decorated by the atomic op.

Detailed Description

template<class ACE_LOCK, class TYPE>
class ACE_Atomic_Op_Ex< ACE_LOCK, TYPE >

Transparently parameterizes synchronization into basic arithmetic operations.

This class is described in an article in the July/August 1994 issue of the C++ Report magazine. It implements a templatized version of the Decorator pattern from the GoF book.

ACE_Atomic_Op_Ex objects must be constructed with a reference to an existing lock. A single lock can be shared between multiple ACE_Atomic_Op_Ex objects. If you do not require this ability consider using the ACE_Atomic_Op class instead, which may be able to take advantage of platform-specific optimisations to provide atomic operations without requiring a lock.


Constructor & Destructor Documentation

template<class ACE_LOCK, class TYPE>
ACE_Atomic_Op_Ex< ACE_LOCK, TYPE >::ACE_Atomic_Op_Ex ( ACE_LOCK &  mtx  ) 

Initialize <value_> to 0.

template<class ACE_LOCK, class TYPE>
ACE_Atomic_Op_Ex< ACE_LOCK, TYPE >::ACE_Atomic_Op_Ex ( ACE_LOCK &  mtx,
const TYPE &  c 
)

Initialize <value_> to c.

template<class ACE_LOCK, class TYPE>
ACE_INLINE ACE_Atomic_Op_Ex< ACE_LOCK, TYPE >::ACE_Atomic_Op_Ex ( const ACE_Atomic_Op_Ex< ACE_LOCK, TYPE > &   ) 

Manage copying...


Member Function Documentation

template<class ACE_LOCK, class TYPE>
void ACE_Atomic_Op_Ex< ACE_LOCK, TYPE >::dump ( void   )  const

Dump the state of an object.

template<class ACE_LOCK, class TYPE>
ACE_BEGIN_VERSIONED_NAMESPACE_DECL ACE_LOCK & ACE_Atomic_Op_Ex< ACE_LOCK, TYPE >::mutex ( void   ) 

Returns a reference to the underlying <ACE_LOCK>. This makes it possible to acquire the lock explicitly, which can be useful in some cases if you instantiate the <ACE_Atomic_Op_Ex> with an ACE_Recursive_Mutex or ACE_Process_Mutex.

Note:
the right name would be lock_, but HP/C++ will choke on that!

template<class ACE_LOCK, class TYPE>
ACE_INLINE bool ACE_Atomic_Op_Ex< ACE_LOCK, TYPE >::operator!= ( const TYPE &  rhs  )  const

Atomically compare <value_> with rhs.

template<class ACE_LOCK, class TYPE>
ACE_INLINE TYPE ACE_Atomic_Op_Ex< ACE_LOCK, TYPE >::operator++ ( int   ) 

Atomically post-increment <value_>.

template<class ACE_LOCK, class TYPE>
ACE_BEGIN_VERSIONED_NAMESPACE_DECL ACE_INLINE TYPE ACE_Atomic_Op_Ex< ACE_LOCK, TYPE >::operator++ ( void   ) 

Atomically pre-increment <value_>.

template<class ACE_LOCK, class TYPE>
ACE_INLINE TYPE ACE_Atomic_Op_Ex< ACE_LOCK, TYPE >::operator+= ( const TYPE &  rhs  ) 

Atomically increment <value_> by rhs.

template<class ACE_LOCK, class TYPE>
ACE_INLINE TYPE ACE_Atomic_Op_Ex< ACE_LOCK, TYPE >::operator-- ( int   ) 

Atomically post-decrement <value_>.

template<class ACE_LOCK, class TYPE>
ACE_INLINE TYPE ACE_Atomic_Op_Ex< ACE_LOCK, TYPE >::operator-- ( void   ) 

Atomically pre-decrement <value_>.

template<class ACE_LOCK, class TYPE>
ACE_INLINE TYPE ACE_Atomic_Op_Ex< ACE_LOCK, TYPE >::operator-= ( const TYPE &  rhs  ) 

Atomically decrement <value_> by rhs.

template<class ACE_LOCK, class TYPE>
ACE_INLINE bool ACE_Atomic_Op_Ex< ACE_LOCK, TYPE >::operator< ( const TYPE &  rhs  )  const

Atomically check if <value_> less than rhs.

template<class ACE_LOCK, class TYPE>
ACE_INLINE bool ACE_Atomic_Op_Ex< ACE_LOCK, TYPE >::operator<= ( const TYPE &  rhs  )  const

Atomically check if <value_> less than or equal to rhs.

template<class ACE_LOCK, class TYPE>
ACE_INLINE ACE_Atomic_Op_Ex< ACE_LOCK, TYPE > & ACE_Atomic_Op_Ex< ACE_LOCK, TYPE >::operator= ( const ACE_Atomic_Op_Ex< ACE_LOCK, TYPE > &  rhs  ) 

Atomically assign <rhs> to <value_>.

template<class ACE_LOCK, class TYPE>
ACE_INLINE ACE_Atomic_Op_Ex< ACE_LOCK, TYPE > & ACE_Atomic_Op_Ex< ACE_LOCK, TYPE >::operator= ( const TYPE &  rhs  ) 

Atomically assign rhs to <value_>.

template<class ACE_LOCK, class TYPE>
ACE_INLINE bool ACE_Atomic_Op_Ex< ACE_LOCK, TYPE >::operator== ( const TYPE &  rhs  )  const

Atomically compare <value_> with rhs.

template<class ACE_LOCK, class TYPE>
ACE_INLINE bool ACE_Atomic_Op_Ex< ACE_LOCK, TYPE >::operator> ( const TYPE &  rhs  )  const

Atomically check if <value_> greater than rhs.

template<class ACE_LOCK, class TYPE>
ACE_INLINE bool ACE_Atomic_Op_Ex< ACE_LOCK, TYPE >::operator>= ( const TYPE &  rhs  )  const

Atomically check if <value_> greater than or equal to rhs.

template<class ACE_LOCK, class TYPE>
ACE_INLINE TYPE ACE_Atomic_Op_Ex< ACE_LOCK, TYPE >::value ( void   )  const

Explicitly return <value_>.

template<class ACE_LOCK, class TYPE>
ACE_INLINE TYPE & ACE_Atomic_Op_Ex< ACE_LOCK, TYPE >::value_i ( void   ) 

Explicitly return <value_> (by reference). This gives the user full, unrestricted access to the underlying value. This method will usually be used in conjunction with explicit access to the lock. Use with care ;-)


Member Data Documentation

template<class ACE_LOCK, class TYPE>
ACE_LOCK& ACE_Atomic_Op_Ex< ACE_LOCK, TYPE >::mutex_ [private]

Type of synchronization mechanism.

template<class ACE_LOCK, class TYPE>
TYPE ACE_Atomic_Op_Ex< ACE_LOCK, TYPE >::value_ [private]

Current object decorated by the atomic op.


The documentation for this class was generated from the following files:
Generated on Tue Nov 21 09:19:07 2006 for ACE by  doxygen 1.4.7-1