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 >:

List of all members.

Public Types
typedef ACE_Type_Traits< TYPE > ::parameter_type	arg_type
Public Member Functions
	ACE_Atomic_Op_Ex (ACE_LOCK &mtx)
	Initialize value_ to 0.
	ACE_Atomic_Op_Ex (ACE_LOCK &mtx, arg_type c)
	Initialize value_ to c.
TYPE	operator++ (void)
	Atomically pre-increment value_.
TYPE	operator++ (int)
	Atomically post-increment value_.
TYPE	operator+= (arg_type rhs)
	Atomically increment value_ by rhs.
TYPE	operator-- (void)
	Atomically pre-decrement value_.
TYPE	operator-- (int)
	Atomically post-decrement value_.
TYPE	operator-= (arg_type rhs)
	Atomically decrement value_ by rhs.
bool	operator== (arg_type rhs) const
	Atomically compare value_ with rhs.
bool	operator!= (arg_type rhs) const
	Atomically compare value_ with rhs.
bool	operator>= (arg_type rhs) const
	Atomically check if value_ greater than or equal to rhs.
bool	operator> (arg_type rhs) const
	Atomically check if value_ greater than rhs.
bool	operator<= (arg_type rhs) const
	Atomically check if value_ less than or equal to rhs.
bool	operator< (arg_type rhs) const
	Atomically check if value_ less than rhs.
ACE_Atomic_Op_Ex< ACE_LOCK, TYPE > &	operator= (arg_type rhs)
	Atomically assign rhs to value_.
ACE_Atomic_Op_Ex< ACE_LOCK, TYPE > &	operator= (ACE_Atomic_Op_Ex< ACE_LOCK, TYPE > const &rhs)
	Atomically assign <rhs> to value_.
TYPE	exchange (TYPE newval)
	Exchange value with newval.
TYPE	value (void) const
	Explicitly return value_.
void	dump (void) const
	Dump the state of an object.
	ACE_Atomic_Op_Ex (ACE_Atomic_Op_Ex< ACE_LOCK, TYPE > const &)
	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, typename 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.

---

Member Typedef Documentation

template<class ACE_LOCK, typename TYPE>

typedef ACE_Type_Traits<TYPE>::parameter_type ACE_Atomic_Op_Ex< ACE_LOCK, TYPE >::arg_type

---

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, typename TYPE>

ACE_Atomic_Op_Ex< ACE_LOCK, TYPE >::ACE_Atomic_Op_Ex	(	ACE_LOCK &	mtx,
		arg_type	c
	)

Initialize value_ to c.

template<class ACE_LOCK, class TYPE>

ACE_Atomic_Op_Ex< ACE_LOCK, TYPE >::ACE_Atomic_Op_Ex

(

ACE_Atomic_Op_Ex< ACE_LOCK, TYPE > const &

rhs

)

[inline]

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>

TYPE ACE_Atomic_Op_Ex< ACE_LOCK, TYPE >::exchange

(

TYPE

newval

)

[inline]

Exchange value with newval.

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, typename TYPE>

bool ACE_Atomic_Op_Ex< ACE_LOCK, TYPE >::operator!=

(

arg_type

rhs

)

const

Atomically compare value_ with rhs.

template<class ACE_LOCK , class TYPE >

TYPE ACE_Atomic_Op_Ex< ACE_LOCK, TYPE >::operator++

(

void

)

[inline]

Atomically pre-increment value_.

template<class ACE_LOCK , class TYPE >

TYPE ACE_Atomic_Op_Ex< ACE_LOCK, TYPE >::operator++

(

int

)

[inline]

Atomically post-increment value_.

template<class ACE_LOCK, typename TYPE>

TYPE ACE_Atomic_Op_Ex< ACE_LOCK, TYPE >::operator+=

(

arg_type

rhs

)

Atomically increment value_ by rhs.

template<class ACE_LOCK , class TYPE >

TYPE ACE_Atomic_Op_Ex< ACE_LOCK, TYPE >::operator--

(

void

)

[inline]

Atomically pre-decrement value_.

template<class ACE_LOCK , class TYPE >

TYPE ACE_Atomic_Op_Ex< ACE_LOCK, TYPE >::operator--

(

int

)

[inline]

Atomically post-decrement value_.

template<class ACE_LOCK, typename TYPE>

TYPE ACE_Atomic_Op_Ex< ACE_LOCK, TYPE >::operator-=

(

arg_type

rhs

)

Atomically decrement value_ by rhs.

template<class ACE_LOCK, typename TYPE>

bool ACE_Atomic_Op_Ex< ACE_LOCK, TYPE >::operator<

(

arg_type

rhs

)

const

Atomically check if value_ less than rhs.

template<class ACE_LOCK, typename TYPE>

bool ACE_Atomic_Op_Ex< ACE_LOCK, TYPE >::operator<=

(

arg_type

rhs

)

const

Atomically check if value_ less than or equal to rhs.

template<class ACE_LOCK, typename TYPE>

ACE_Atomic_Op_Ex<ACE_LOCK, TYPE>& ACE_Atomic_Op_Ex< ACE_LOCK, TYPE >::operator=

(

arg_type

rhs

)

Atomically assign rhs to value_.

template<class ACE_LOCK, class TYPE>

ACE_Atomic_Op_Ex< ACE_LOCK, TYPE > & ACE_Atomic_Op_Ex< ACE_LOCK, TYPE >::operator=

(

ACE_Atomic_Op_Ex< ACE_LOCK, TYPE > const &

rhs

)

[inline]

Atomically assign <rhs> to value_.

template<class ACE_LOCK, typename TYPE>

bool ACE_Atomic_Op_Ex< ACE_LOCK, TYPE >::operator==

(

arg_type

rhs

)

const

Atomically compare value_ with rhs.

template<class ACE_LOCK, typename TYPE>

bool ACE_Atomic_Op_Ex< ACE_LOCK, TYPE >::operator>

(

arg_type

rhs

)

const

Atomically check if value_ greater than rhs.

template<class ACE_LOCK, typename TYPE>

bool ACE_Atomic_Op_Ex< ACE_LOCK, TYPE >::operator>=

(

arg_type

rhs

)

const

Atomically check if value_ greater than or equal to rhs.

template<class ACE_LOCK , class TYPE >

TYPE ACE_Atomic_Op_Ex< ACE_LOCK, TYPE >::value

(

void

)

const [inline]

Explicitly return value_.

template<class ACE_LOCK , class TYPE >

TYPE & ACE_Atomic_Op_Ex< 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, typename TYPE>

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

Type of synchronization mechanism.

template<class ACE_LOCK, typename 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:

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