---

ACE_Atomic_Op_Ex< ACE_LOCK, TYPE > Class Template Reference

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

#include <Atomic_Op_T.h>

Inheritance diagram for ACE_Atomic_Op_Ex< ACE_LOCK, TYPE >:

[legend]Collaboration diagram for ACE_Atomic_Op_Ex< ACE_LOCK, TYPE >:

[legend]List of all members.

Public Methods
	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.
int	operator== (const TYPE &rhs) const
	Atomically compare <value_> with rhs.
int	operator!= (const TYPE &rhs) const
	Atomically compare <value_> with rhs.
int	operator>= (const TYPE &rhs) const
	Atomically check if <value_> greater than or equal to rhs.
int	operator> (const TYPE &rhs) const
	Atomically check if <value_> greater than rhs.
int	operator<= (const TYPE &rhs) const
	Atomically check if <value_> less than or equal to rhs.
int	operator< (const TYPE &rhs) const
	Atomically check if <value_> less than rhs.
void	operator= (const TYPE &rhs)
	Atomically assign rhs to <value_>.
void	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_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 int 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_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 int 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 int 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 void 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 void ACE_Atomic_Op_Ex< ACE_LOCK, TYPE >::operator= (  const TYPE &    rhs )

Atomically assign rhs to <value_>.

template<class ACE_LOCK, class TYPE> ACE_INLINE int 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 int 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 int 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:

• /export2/deucetmp/bala/release_try/ACE_wrappers/ace/Atomic_Op_T.h
• /export2/deucetmp/bala/release_try/ACE_wrappers/ace/Atomic_Op_T.cpp
• /export2/deucetmp/bala/release_try/ACE_wrappers/ace/Atomic_Op_T.i

---