diff options
Diffstat (limited to 'ace/Atomic_Op_T.h')
-rw-r--r-- | ace/Atomic_Op_T.h | 254 |
1 files changed, 0 insertions, 254 deletions
diff --git a/ace/Atomic_Op_T.h b/ace/Atomic_Op_T.h deleted file mode 100644 index 89703186356..00000000000 --- a/ace/Atomic_Op_T.h +++ /dev/null @@ -1,254 +0,0 @@ -/* -*- C++ -*- */ - -//============================================================================= -/** - * @file Atomic_Op_T.h - * - * $Id$ - * - * @author Douglas C. Schmidt <schmidt@uci.edu> - */ -//============================================================================= - -#ifndef ACE_ATOMIC_OP_T_H -#define ACE_ATOMIC_OP_T_H -#include /**/ "ace/pre.h" - -#include "ace/config-all.h" - -#if !defined (ACE_LACKS_PRAGMA_ONCE) -# pragma once -#endif /* ACE_LACKS_PRAGMA_ONCE */ - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -/** - * @class ACE_Atomic_Op_Ex - * - * @brief 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. - */ -template <class ACE_LOCK, class TYPE> -class ACE_Atomic_Op_Ex -{ -public: - // = Initialization methods. - - /// Initialize <value_> to 0. - ACE_Atomic_Op_Ex (ACE_LOCK &mtx); - - /// Initialize <value_> to c. - ACE_Atomic_Op_Ex (ACE_LOCK &mtx, const TYPE &c); - - // = Accessors. - - /// Atomically pre-increment <value_>. - TYPE operator++ (void); - - /// Atomically post-increment <value_>. - TYPE operator++ (int); - - /// Atomically increment <value_> by rhs. - TYPE operator+= (const TYPE &rhs); - - /// Atomically pre-decrement <value_>. - TYPE operator-- (void); - - /// Atomically post-decrement <value_>. - TYPE operator-- (int); - - /// Atomically decrement <value_> by rhs. - TYPE operator-= (const TYPE &rhs); - - /// 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. - bool operator< (const TYPE &rhs) const; - - /// Atomically assign rhs to <value_>. - ACE_Atomic_Op_Ex<ACE_LOCK, TYPE> &operator= (const TYPE &rhs); - - /// Atomically assign <rhs> to <value_>. - ACE_Atomic_Op_Ex<ACE_LOCK, TYPE> &operator= (const ACE_Atomic_Op_Ex<ACE_LOCK, TYPE> &rhs); - - /// Explicitly return <value_>. - TYPE value (void) const; - - /// Dump the state of an object. - void dump (void) const; - - // ACE_ALLOC_HOOK_DECLARE; - // Declare the dynamic allocation hooks. - - /// Manage copying... - ACE_Atomic_Op_Ex (const ACE_Atomic_Op_Ex<ACE_LOCK, TYPE> &); - - /** - * 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! - */ - ACE_LOCK &mutex (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 ;-) - */ - TYPE &value_i (void); - -private: - /// Type of synchronization mechanism. - ACE_LOCK &mutex_; - - /// Current object decorated by the atomic op. - TYPE value_; -}; - -/** - * @class ACE_Atomic_Op - * - * @brief 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. - */ -template <class ACE_LOCK, class TYPE> -class ACE_Atomic_Op -{ -public: - /// Initialize <value_> to 0. - ACE_Atomic_Op (void); - - /// Initialize <value_> to c. - ACE_Atomic_Op (const TYPE &c); - - /// Manage copying... - ACE_Atomic_Op (const ACE_Atomic_Op<ACE_LOCK, TYPE> &c); - - /// Atomically assign rhs to <value_>. - 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 pre-increment <value_>. - TYPE operator++ (void); - - /// Atomically post-increment <value_>. - TYPE operator++ (int); - - /// Atomically increment <value_> by rhs. - TYPE operator+= (const TYPE &rhs); - - /// Atomically pre-decrement <value_>. - TYPE operator-- (void); - - /// Atomically post-decrement <value_>. - TYPE operator-- (int); - - /// Atomically decrement <value_> by rhs. - TYPE operator-= (const TYPE &rhs); - - /// 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. - bool operator< (const TYPE &rhs) const; - - /// Explicitly return <value_>. - TYPE value (void) const; - - /// Dump the state of an object. - void dump (void) const; - - /** - * 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. - */ - ACE_LOCK &mutex (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 ;-) - */ - TYPE &value_i (void); - -private: - /// Type of synchronization mechanism. - ACE_LOCK own_mutex_; - - /// Underlying atomic op implementation. - ACE_Atomic_Op_Ex <ACE_LOCK, TYPE> impl_; -}; - -ACE_END_VERSIONED_NAMESPACE_DECL - -#if defined (__ACE_INLINE__) -#include "ace/Atomic_Op_T.inl" -#endif /* __ACE_INLINE__ */ - -#if defined (ACE_TEMPLATES_REQUIRE_SOURCE) -#include "ace/Atomic_Op_T.cpp" -#endif /* ACE_TEMPLATES_REQUIRE_SOURCE */ - -#if defined (ACE_TEMPLATES_REQUIRE_PRAGMA) -#pragma implementation ("Atomic_Op_T.cpp") -#endif /* ACE_TEMPLATES_REQUIRE_PRAGMA */ - -#include /**/ "ace/post.h" -#endif /*ACE_ATOMIC_OP_T_H*/ |