Main Page Namespace List Class Hierarchy Alphabetical List Compound List File List Namespace Members Compound Members File Members Related Pages

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

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

[legend]
List of all members.

## Public Methods

| 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...
void | operator= (const TYPE &rhs)
| Atomically assign rhs to <value_>.
void | 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.
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.
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 |  | ) |

| Initialize <value_> to 0.

template<class ACE_LOCK, class TYPE>
ACE_Atomic_Op< ACE_LOCK, TYPE >::ACE_Atomic_Op | ( | const TYPE & | c | ) |

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

| Manage copying...

## Member Function Documentation

template<class ACE_LOCK, class TYPE>
ACE_INLINE void ACE_Atomic_Op< ACE_LOCK, TYPE >::dump | ( | void |  | ) | const

| Dump the state of an object.

template<class ACE_LOCK, class TYPE>
ACE_INLINE ACE_LOCK & ACE_Atomic_Op< 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> with an <ACE_Recursive_Mutex> or <ACE_Process_Mutex>.

NOTE: 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 int ACE_Atomic_Op< 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< ACE_LOCK, TYPE >::operator++ | ( | int |  | ) |

| Atomically post-increment <value_>.

template<class ACE_LOCK, class TYPE>
ACE_INLINE TYPE ACE_Atomic_Op< ACE_LOCK, TYPE >::operator++ | ( | void |  | ) |

| Atomically pre-increment <value_>.

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

| Atomically increment <value_> by rhs.

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

| Atomically post-decrement <value_>.

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

| Atomically pre-decrement <value_>.

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

| Atomically decrement <value_> by rhs.

template<class ACE_LOCK, class TYPE>
ACE_INLINE int ACE_Atomic_Op< 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< 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< ACE_LOCK, TYPE >::operator= | ( | const ACE_Atomic_Op< ACE_LOCK, TYPE > & | rhs | ) |

| Atomically assign <rhs> to <value_>.

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

| Atomically assign rhs to <value_>.

template<class ACE_LOCK, class TYPE>
ACE_INLINE int ACE_Atomic_Op< 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< 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< 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< ACE_LOCK, TYPE >::value | ( | void |  | ) | const

| Explicitly return <value_>.

template<class ACE_LOCK, class TYPE>
ACE_INLINE TYPE & ACE_Atomic_Op< 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_Atomic_Op_Ex<ACE_LOCK, TYPE> ACE_Atomic_Op< ACE_LOCK, TYPE >::impl_`[private]`

| Underlying atomic op implementation.

template<class ACE_LOCK, class TYPE>
ACE_LOCK ACE_Atomic_Op< ACE_LOCK, TYPE >::own_mutex_`[private]`

| Type of synchronization mechanism.

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