Go to the documentation of this file.00001
00002
00003
00004
00005 #if defined (ACE_HAS_GCC_ATOMIC_BUILTINS) && (ACE_HAS_GCC_ATOMIC_BUILTINS == 1)
00006
00007 ACE_BEGIN_VERSIONED_NAMESPACE_DECL
00008
00009 template <typename T>
00010 ACE_INLINE
00011 ACE_Atomic_Op_GCC<T>::ACE_Atomic_Op_GCC (void)
00012 : value_ (0)
00013 {
00014 }
00015
00016 template <typename T>
00017 ACE_INLINE
00018 ACE_Atomic_Op_GCC<T>::ACE_Atomic_Op_GCC (T c)
00019 : value_ (c)
00020 {
00021 }
00022
00023 template <typename T>
00024 ACE_INLINE
00025 ACE_Atomic_Op_GCC<T>::ACE_Atomic_Op_GCC (
00026 const ACE_Atomic_Op_GCC<T> &rhs)
00027 : value_ (rhs.value_)
00028 {
00029 }
00030
00031 template <typename T>
00032 ACE_INLINE T
00033 ACE_Atomic_Op_GCC<T>::operator++ (void)
00034 {
00035 return __sync_add_and_fetch (&this->value_, 1);
00036 }
00037
00038 template <typename T>
00039 ACE_INLINE T
00040 ACE_Atomic_Op_GCC<T>::operator++ (int)
00041 {
00042 return __sync_fetch_and_add (&this->value_, 1);
00043 }
00044
00045 template <typename T>
00046 ACE_INLINE T
00047 ACE_Atomic_Op_GCC<T>::operator-- (void)
00048 {
00049 return __sync_sub_and_fetch (&this->value_, 1);
00050 }
00051
00052 template <typename T>
00053 ACE_INLINE T
00054 ACE_Atomic_Op_GCC<T>::operator-- (int)
00055 {
00056 return __sync_fetch_and_sub (&this->value_, 1);
00057 }
00058
00059 template <typename T>
00060 ACE_INLINE T
00061 ACE_Atomic_Op_GCC<T>::operator+= (T rhs)
00062 {
00063 return __sync_add_and_fetch (&this->value_, rhs);
00064 }
00065
00066 template <typename T>
00067 ACE_INLINE T
00068 ACE_Atomic_Op_GCC<T>::operator-= (T rhs)
00069 {
00070 return __sync_sub_and_fetch (&this->value_, rhs);
00071 }
00072
00073 template <typename T>
00074 ACE_INLINE bool
00075 ACE_Atomic_Op_GCC<T>::operator== (T rhs) const
00076 {
00077 return (this->value_ == rhs);
00078 }
00079
00080 template <typename T>
00081 ACE_INLINE bool
00082 ACE_Atomic_Op_GCC<T>::operator!= (T rhs) const
00083 {
00084 return (this->value_ != rhs);
00085 }
00086
00087 template <typename T>
00088 ACE_INLINE bool
00089 ACE_Atomic_Op_GCC<T>::operator>= (T rhs) const
00090 {
00091 return (this->value_ >= rhs);
00092 }
00093
00094 template <typename T>
00095 ACE_INLINE bool
00096 ACE_Atomic_Op_GCC<T>::operator> (T rhs) const
00097 {
00098 return (this->value_ > rhs);
00099 }
00100
00101 template <typename T>
00102 ACE_INLINE bool
00103 ACE_Atomic_Op_GCC<T>::operator<= (T rhs) const
00104 {
00105 return (this->value_ <= rhs);
00106 }
00107
00108 template <typename T>
00109 ACE_INLINE bool
00110 ACE_Atomic_Op_GCC<T>::operator< (T rhs) const
00111 {
00112 return (this->value_ < rhs);
00113 }
00114
00115 template <typename T>
00116 ACE_INLINE ACE_Atomic_Op_GCC<T> &
00117 ACE_Atomic_Op_GCC<T>::operator= (T rhs)
00118 {
00119 (void) __sync_lock_test_and_set (&this->value_, rhs);
00120 return *this;
00121 }
00122
00123 template <typename T>
00124 ACE_INLINE ACE_Atomic_Op_GCC<T> &
00125 ACE_Atomic_Op_GCC<T>::operator= (
00126 const ACE_Atomic_Op_GCC<T> &rhs)
00127 {
00128 (void) __sync_lock_test_and_set (&this->value_, rhs.value_);
00129 return *this;
00130 }
00131
00132 template <typename T>
00133 ACE_INLINE T
00134 ACE_Atomic_Op_GCC<T>::value (void) const
00135 {
00136 return this->value_;
00137 }
00138
00139 template <typename T>
00140 ACE_INLINE volatile T &
00141 ACE_Atomic_Op_GCC<T>::value_i (void)
00142 {
00143 return this->value_;
00144 }
00145
00146 ACE_END_VERSIONED_NAMESPACE_DECL
00147
00148 #endif