NAME
ACE_Atomic_Op - Transparently parameterizes synchronization into basic arithmetic operations.
SYNOPSIS
#include <ace/Synch_T.h>
template<class ACE_LOCK, class TYPE>
class ACE_Atomic_Op
{
public:
ACE_Atomic_Op (void);
ACE_Atomic_Op (const TYPE &c);
TYPE operator++ (void);
TYPE operator++ (int);
TYPE operator+= (const TYPE &i);
TYPE operator-- (void);
TYPE operator-- (int);
TYPE operator-= (const TYPE &i);
int operator== (const TYPE &i) const;
int operator!= (const TYPE &i) const;
int operator>= (const TYPE &i) const;
int operator> (const TYPE &rhs) const;
int operator<= (const TYPE &rhs) const;
int operator< (const TYPE &rhs) const;
void operator= (const TYPE &i);
void operator= (const ACE_Atomic_Op<ACE_LOCK, TYPE> &rhs);
TYPE value (void) const;
void dump (void) const;
ACE_Atomic_Op (const ACE_Atomic_Op<ACE_LOCK, TYPE> &);
ACE_LOCK &mutex (void);
TYPE &value_i (void);
private:
ACE_LOCK mutex_;
TYPE value_;
};
DESCRIPTION
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.
Initialization methods.
ACE_Atomic_Op (void);
Initialize value_ to 0.
ACE_Atomic_Op (const TYPE &c);
Initialize value_ to c.
Accessors.
TYPE operator++ (void);
Atomically pre-increment value_.
TYPE operator++ (int);
Atomically post-increment value_.
TYPE operator+= (const TYPE &i);
Atomically increment value_ by i.
TYPE operator-- (void);
Atomically pre-decrement value_.
TYPE operator-- (int);
Atomically post-decrement value_.
TYPE operator-= (const TYPE &i);
Atomically decrement value_ by i.
int operator== (const TYPE &i) const;
Atomically compare value_ with i.
int operator!= (const TYPE &i) const;
Atomically compare value_ with i.
int operator>= (const TYPE &i) const;
Atomically check if value_ greater than or equal to i.
int operator> (const TYPE &rhs) const;
Atomically check if value_ greater than i.
int operator<= (const TYPE &rhs) const;
Atomically check if value_ less than or equal to i.
int operator< (const TYPE &rhs) const;
Atomically check if value_ less than i.
void operator= (const TYPE &i);
Atomically assign i to value_.
void operator= (const ACE_Atomic_Op<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_ALLOC_HOOK_DECLARE; Declare the dynamic allocation hooks.
ACE_Atomic_Op (const ACE_Atomic_Op<ACE_LOCK, TYPE> &);
Manage copying...
ACE_LOCK &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: the right name would be lock_, but HP/C++ will choke on that!
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 ;-)
AUTHOR
Doug Schmidt
LIBRARY
ace