ACE_Atomic_Op< 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< ACE_LOCK, TYPE >:

[legend]

List of all members.

Public Member Functions
	ACE_Atomic_Op (void)
	Initialize value_ to 0.
	ACE_Atomic_Op (const TYPE &c)
	Initialize value_ to c.
	ACE_Atomic_Op (const ACE_Atomic_Op< ACE_LOCK, TYPE > &c)
	Manage copying...
ACE_Atomic_Op < ACE_LOCK, TYPE > &	operator= (const TYPE &rhs)
	Atomically assign rhs to value_.
ACE_Atomic_Op < ACE_LOCK, TYPE > &	operator= (const ACE_Atomic_Op< ACE_LOCK, TYPE > &rhs)
	Atomically assign <rhs> to value_.
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.
TYPE	value (void) const
	Explicitly return value_.
void	dump (void) const
	Dump the state of an object.
ACE_LOCK &	mutex (void)
TYPE &	value_i (void)
Private Attributes
ACE_LOCK	own_mutex_
	Type of synchronization mechanism.
ACE_Atomic_Op_Ex < ACE_LOCK, TYPE >	impl_
	Underlying atomic op implementation.

---

Detailed Description

template<class ACE_LOCK, class TYPE>
class ACE_Atomic_Op< 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.

Certain platforms may provide a template specialization for ACE_Atomic_Op <ACE_Thread_Mutex, long> that provides optimized atomic integer operations without actually requiring a mutex.

---

Constructor & Destructor Documentation

template<class ACE_LOCK, class TYPE>

ACE_Atomic_Op< ACE_LOCK, TYPE >::ACE_Atomic_Op

(

void

)

[inline]

Initialize value_ to 0.

template<class ACE_LOCK, class TYPE>

ACE_Atomic_Op< ACE_LOCK, TYPE >::ACE_Atomic_Op

(

const TYPE &

c

)

[inline]

Initialize value_ to c.

template<class ACE_LOCK, class TYPE>

ACE_INLINE ACE_Atomic_Op< ACE_LOCK, TYPE >::ACE_Atomic_Op

(

const ACE_Atomic_Op< ACE_LOCK, TYPE > &

c

)

[inline]

Manage copying...

---

Member Function Documentation

template<class ACE_LOCK, class TYPE>

ACE_INLINE ACE_Atomic_Op< ACE_LOCK, TYPE > & ACE_Atomic_Op< ACE_LOCK, TYPE >::operator=

(

const TYPE &

rhs

)

[inline]

Atomically assign rhs to value_.

template<class ACE_LOCK, class TYPE>

ACE_INLINE ACE_Atomic_Op< ACE_LOCK, TYPE > & ACE_Atomic_Op< ACE_LOCK, TYPE >::operator=

(

const ACE_Atomic_Op< ACE_LOCK, TYPE > &

rhs

)

[inline]

Atomically assign <rhs> to value_.

template<class ACE_LOCK, class TYPE>

ACE_INLINE TYPE ACE_Atomic_Op< ACE_LOCK, TYPE >::operator++

(

void

)

[inline]

Atomically pre-increment value_.

template<class ACE_LOCK, class TYPE>

ACE_INLINE TYPE ACE_Atomic_Op< ACE_LOCK, TYPE >::operator++

(

int

)

[inline]

Atomically post-increment value_.

template<class ACE_LOCK, class TYPE>

ACE_INLINE TYPE ACE_Atomic_Op< ACE_LOCK, TYPE >::operator+=

(

const TYPE &

rhs

)

[inline]

Atomically increment value_ by rhs.

template<class ACE_LOCK, class TYPE>

ACE_INLINE TYPE ACE_Atomic_Op< ACE_LOCK, TYPE >::operator--

(

void

)

[inline]

Atomically pre-decrement value_.

template<class ACE_LOCK, class TYPE>

ACE_INLINE TYPE ACE_Atomic_Op< ACE_LOCK, TYPE >::operator--

(

int

)

[inline]

Atomically post-decrement value_.

template<class ACE_LOCK, class TYPE>

ACE_INLINE TYPE ACE_Atomic_Op< ACE_LOCK, TYPE >::operator-=

(

const TYPE &

rhs

)

[inline]

Atomically decrement value_ by rhs.

template<class ACE_LOCK, class TYPE>

ACE_INLINE bool ACE_Atomic_Op< ACE_LOCK, TYPE >::operator==

(

const TYPE &

rhs

)

const [inline]

Atomically compare value_ with rhs.

template<class ACE_LOCK, class TYPE>

ACE_INLINE bool ACE_Atomic_Op< ACE_LOCK, TYPE >::operator!=

(

const TYPE &

rhs

)

const [inline]

Atomically compare value_ with rhs.

template<class ACE_LOCK, class TYPE>

ACE_INLINE bool ACE_Atomic_Op< ACE_LOCK, TYPE >::operator>=

(

const TYPE &

rhs

)

const [inline]

Atomically check if value_ greater than or equal to rhs.

template<class ACE_LOCK, class TYPE>

ACE_INLINE bool ACE_Atomic_Op< ACE_LOCK, TYPE >::operator>

(

const TYPE &

rhs

)

const [inline]

Atomically check if value_ greater than rhs.

template<class ACE_LOCK, class TYPE>

ACE_INLINE bool ACE_Atomic_Op< ACE_LOCK, TYPE >::operator<=

(

const TYPE &

rhs

)

const [inline]

Atomically check if value_ less than or equal to rhs.

template<class ACE_LOCK, class TYPE>

ACE_INLINE bool ACE_Atomic_Op< ACE_LOCK, TYPE >::operator<

(

const TYPE &

rhs

)

const [inline]

Atomically check if value_ less than rhs.

template<class ACE_LOCK, class TYPE>

ACE_INLINE TYPE ACE_Atomic_Op< ACE_LOCK, TYPE >::value

(

void

)

const [inline]

Explicitly return value_.

template<class ACE_LOCK, class TYPE>

ACE_INLINE void ACE_Atomic_Op< ACE_LOCK, TYPE >::dump

(

void

)

const [inline]

Dump the state of an object.

template<class ACE_LOCK, class TYPE>

ACE_INLINE ACE_LOCK & ACE_Atomic_Op< ACE_LOCK, TYPE >::mutex

(

void

)

[inline]

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 with an ACE_Recursive_Mutex or ACE_Process_Mutex.

Deprecated:

This member function is deprecated and so may go away in the future. If you need access to the underlying mutex, consider using the ACE_Atomic_Op_Ex template instead.

template<class ACE_LOCK, class TYPE>

ACE_INLINE TYPE & ACE_Atomic_Op< ACE_LOCK, TYPE >::value_i

(

void

)

[inline]

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< ACE_LOCK, TYPE >::own_mutex_ [private]

Type of synchronization mechanism.

template<class ACE_LOCK, class TYPE>

ACE_Atomic_Op_Ex<ACE_LOCK, TYPE> ACE_Atomic_Op< ACE_LOCK, TYPE >::impl_ [private]

Underlying atomic op implementation.

---

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

• Atomic_Op_T.h
• Atomic_Op_T.cpp
• Atomic_Op_T.inl

---