00001
00002
00003
00004
00005 #include "ace/Guard_T.h"
00006
00007 #include <algorithm>
00008
00009 ACE_BEGIN_VERSIONED_NAMESPACE_DECL
00010
00011
00012
00013
00014
00015 template <class ACE_LOCK, class TYPE>
00016 ACE_INLINE TYPE
00017 ACE_Atomic_Op_Ex<ACE_LOCK, TYPE>::operator++ (void)
00018 {
00019
00020 ACE_GUARD_RETURN (ACE_LOCK, ace_mon, this->mutex_, this->value_);
00021 return ++this->value_;
00022 }
00023
00024 template <class ACE_LOCK, class TYPE>
00025 ACE_INLINE TYPE
00026 ACE_Atomic_Op_Ex<ACE_LOCK, TYPE>::operator+= (
00027 typename ACE_Atomic_Op_Ex<ACE_LOCK, TYPE>::arg_type rhs)
00028 {
00029
00030 ACE_GUARD_RETURN (ACE_LOCK, ace_mon, this->mutex_, this->value_);
00031 return this->value_ += rhs;
00032 }
00033
00034 template <class ACE_LOCK, class TYPE>
00035 ACE_INLINE TYPE
00036 ACE_Atomic_Op_Ex<ACE_LOCK, TYPE>::operator-- (void)
00037 {
00038
00039 ACE_GUARD_RETURN (ACE_LOCK, ace_mon, this->mutex_, this->value_);
00040 return --this->value_;
00041 }
00042
00043 template <class ACE_LOCK, class TYPE>
00044 ACE_INLINE TYPE
00045 ACE_Atomic_Op_Ex<ACE_LOCK, TYPE>::operator-= (
00046 typename ACE_Atomic_Op_Ex<ACE_LOCK, TYPE>::arg_type rhs)
00047 {
00048
00049 ACE_GUARD_RETURN (ACE_LOCK, ace_mon, this->mutex_, this->value_);
00050 return this->value_ -= rhs;
00051 }
00052
00053 template <class ACE_LOCK, class TYPE>
00054 ACE_INLINE
00055 ACE_Atomic_Op_Ex<ACE_LOCK, TYPE>::ACE_Atomic_Op_Ex (
00056 ACE_Atomic_Op_Ex<ACE_LOCK, TYPE> const & rhs)
00057 : mutex_ (rhs.mutex_)
00058 , value_ (rhs.value ())
00059 {
00060
00061 }
00062
00063 template <class ACE_LOCK, class TYPE>
00064 ACE_INLINE TYPE
00065 ACE_Atomic_Op_Ex<ACE_LOCK, TYPE>::operator++ (int)
00066 {
00067
00068 ACE_GUARD_RETURN (ACE_LOCK, ace_mon, this->mutex_, this->value_);
00069 return this->value_++;
00070 }
00071
00072 template <class ACE_LOCK, class TYPE>
00073 ACE_INLINE TYPE
00074 ACE_Atomic_Op_Ex<ACE_LOCK, TYPE>::operator-- (int)
00075 {
00076
00077 ACE_GUARD_RETURN (ACE_LOCK, ace_mon, this->mutex_, this->value_);
00078 return this->value_--;
00079 }
00080
00081 template <class ACE_LOCK, class TYPE>
00082 ACE_INLINE bool
00083 ACE_Atomic_Op_Ex<ACE_LOCK, TYPE>::operator== (
00084 typename ACE_Atomic_Op_Ex<ACE_LOCK, TYPE>::arg_type rhs) const
00085 {
00086
00087 ACE_GUARD_RETURN (ACE_LOCK, ace_mon, this->mutex_, false);
00088 return this->value_ == rhs;
00089 }
00090
00091 template <class ACE_LOCK, class TYPE>
00092 ACE_INLINE bool
00093 ACE_Atomic_Op_Ex<ACE_LOCK, TYPE>::operator!= (
00094 typename ACE_Atomic_Op_Ex<ACE_LOCK, TYPE>::arg_type rhs) const
00095 {
00096
00097 return !(*this == rhs);
00098 }
00099
00100 template <class ACE_LOCK, class TYPE>
00101 ACE_INLINE bool
00102 ACE_Atomic_Op_Ex<ACE_LOCK, TYPE>::operator>= (
00103 typename ACE_Atomic_Op_Ex<ACE_LOCK, TYPE>::arg_type rhs) const
00104 {
00105
00106 ACE_GUARD_RETURN (ACE_LOCK, ace_mon, this->mutex_, false);
00107 return this->value_ >= rhs;
00108 }
00109
00110 template <class ACE_LOCK, class TYPE>
00111 ACE_INLINE bool
00112 ACE_Atomic_Op_Ex<ACE_LOCK, TYPE>::operator> (
00113 typename ACE_Atomic_Op_Ex<ACE_LOCK, TYPE>::arg_type rhs) const
00114 {
00115
00116 ACE_GUARD_RETURN (ACE_LOCK, ace_mon, this->mutex_, false);
00117 return this->value_ > rhs;
00118 }
00119
00120 template <class ACE_LOCK, class TYPE>
00121 ACE_INLINE bool
00122 ACE_Atomic_Op_Ex<ACE_LOCK, TYPE>::operator<= (
00123 typename ACE_Atomic_Op_Ex<ACE_LOCK, TYPE>::arg_type rhs) const
00124 {
00125
00126 ACE_GUARD_RETURN (ACE_LOCK, ace_mon, this->mutex_, false);
00127 return this->value_ <= rhs;
00128 }
00129
00130 template <class ACE_LOCK, class TYPE>
00131 ACE_INLINE bool
00132 ACE_Atomic_Op_Ex<ACE_LOCK, TYPE>::operator< (
00133 typename ACE_Atomic_Op_Ex<ACE_LOCK, TYPE>::arg_type rhs) const
00134 {
00135
00136 ACE_GUARD_RETURN (ACE_LOCK, ace_mon, this->mutex_, false);
00137 return this->value_ < rhs;
00138 }
00139
00140 template <class ACE_LOCK, class TYPE>
00141 ACE_INLINE ACE_Atomic_Op_Ex<ACE_LOCK, TYPE> &
00142 ACE_Atomic_Op_Ex<ACE_LOCK, TYPE>::operator= (
00143 ACE_Atomic_Op_Ex<ACE_LOCK, TYPE> const & rhs)
00144 {
00145
00146
00147 ACE_Atomic_Op_Ex<ACE_LOCK, TYPE> tmp (rhs);
00148
00149 ACE_GUARD_RETURN (ACE_LOCK, ace_mon, this->mutex_, *this);
00150 std::swap (this->value_, tmp.value_);
00151
00152 return *this;
00153 }
00154
00155 template <class ACE_LOCK, class TYPE>
00156 ACE_INLINE TYPE
00157 ACE_Atomic_Op_Ex<ACE_LOCK, TYPE>::value (void) const
00158 {
00159
00160 ACE_GUARD_RETURN (ACE_LOCK, ace_mon, this->mutex_, this->value_);
00161 return this->value_;
00162 }
00163
00164 template <class ACE_LOCK, class TYPE>
00165 ACE_INLINE TYPE &
00166 ACE_Atomic_Op_Ex<ACE_LOCK, TYPE>::value_i (void)
00167 {
00168
00169
00170
00171
00172 return this->value_;
00173 }
00174
00175 template <class ACE_LOCK, class TYPE>
00176 ACE_INLINE ACE_Atomic_Op_Ex<ACE_LOCK, TYPE> &
00177 ACE_Atomic_Op_Ex<ACE_LOCK, TYPE>::operator= (
00178 typename ACE_Atomic_Op_Ex<ACE_LOCK, TYPE>::arg_type rhs)
00179 {
00180
00181 ACE_GUARD_RETURN (ACE_LOCK, ace_mon, this->mutex_, *this);
00182 this->value_ = rhs;
00183 return *this;
00184 }
00185
00186
00187
00188
00189
00190 template <class ACE_LOCK, class TYPE> ACE_INLINE
00191 ACE_Atomic_Op<ACE_LOCK, TYPE>::ACE_Atomic_Op (
00192 ACE_Atomic_Op<ACE_LOCK, TYPE> const & rhs)
00193 : impl_ (own_mutex_, rhs.value ())
00194 {
00195
00196 }
00197
00198
00199 template <class ACE_LOCK, class TYPE>
00200 ACE_INLINE ACE_Atomic_Op<ACE_LOCK, TYPE> &
00201 ACE_Atomic_Op<ACE_LOCK, TYPE>::operator= (
00202 typename ACE_Atomic_Op<ACE_LOCK, TYPE>::arg_type i)
00203 {
00204 this->impl_ = i;
00205 return *this;
00206 }
00207
00208 template <class ACE_LOCK, class TYPE>
00209 ACE_INLINE ACE_Atomic_Op<ACE_LOCK, TYPE> &
00210 ACE_Atomic_Op<ACE_LOCK, TYPE>::operator= (
00211 ACE_Atomic_Op<ACE_LOCK, TYPE> const & rhs)
00212 {
00213 this->impl_ = rhs.impl_;
00214 return *this;
00215 }
00216
00217 template <class ACE_LOCK, class TYPE>
00218 ACE_INLINE TYPE
00219 ACE_Atomic_Op<ACE_LOCK, TYPE>::operator++ (void)
00220 {
00221 return ++this->impl_;
00222 }
00223
00224 template <class ACE_LOCK, class TYPE>
00225 ACE_INLINE TYPE
00226 ACE_Atomic_Op<ACE_LOCK, TYPE>::operator++ (int)
00227 {
00228 return this->impl_++;
00229 }
00230
00231 template <class ACE_LOCK, class TYPE>
00232 ACE_INLINE TYPE
00233 ACE_Atomic_Op<ACE_LOCK, TYPE>::operator+= (
00234 typename ACE_Atomic_Op<ACE_LOCK, TYPE>::arg_type rhs)
00235 {
00236 return this->impl_ += rhs;
00237 }
00238
00239 template <class ACE_LOCK, class TYPE>
00240 ACE_INLINE TYPE
00241 ACE_Atomic_Op<ACE_LOCK, TYPE>::operator-- (void)
00242 {
00243 return --this->impl_;
00244 }
00245
00246 template <class ACE_LOCK, class TYPE>
00247 ACE_INLINE TYPE
00248 ACE_Atomic_Op<ACE_LOCK, TYPE>::operator-- (int)
00249 {
00250 return this->impl_--;
00251 }
00252
00253 template <class ACE_LOCK, class TYPE>
00254 ACE_INLINE TYPE
00255 ACE_Atomic_Op<ACE_LOCK, TYPE>::operator-= (
00256 typename ACE_Atomic_Op<ACE_LOCK, TYPE>::arg_type rhs)
00257 {
00258 return this->impl_ -= rhs;
00259 }
00260
00261 template <class ACE_LOCK, class TYPE>
00262 ACE_INLINE bool
00263 ACE_Atomic_Op<ACE_LOCK, TYPE>::operator== (
00264 typename ACE_Atomic_Op<ACE_LOCK, TYPE>::arg_type rhs) const
00265 {
00266 return this->impl_ == rhs;
00267 }
00268
00269 template <class ACE_LOCK, class TYPE>
00270 ACE_INLINE bool
00271 ACE_Atomic_Op<ACE_LOCK, TYPE>::operator!= (
00272 typename ACE_Atomic_Op<ACE_LOCK, TYPE>::arg_type rhs) const
00273 {
00274 return this->impl_ != rhs;
00275 }
00276
00277 template <class ACE_LOCK, class TYPE>
00278 ACE_INLINE bool
00279 ACE_Atomic_Op<ACE_LOCK, TYPE>::operator>= (
00280 typename ACE_Atomic_Op<ACE_LOCK, TYPE>::arg_type rhs) const
00281 {
00282 return this->impl_ >= rhs;
00283 }
00284
00285 template <class ACE_LOCK, class TYPE>
00286 ACE_INLINE bool
00287 ACE_Atomic_Op<ACE_LOCK, TYPE>::operator> (
00288 typename ACE_Atomic_Op<ACE_LOCK, TYPE>::arg_type rhs) const
00289 {
00290 return this->impl_ > rhs;
00291 }
00292
00293 template <class ACE_LOCK, class TYPE>
00294 ACE_INLINE bool
00295 ACE_Atomic_Op<ACE_LOCK, TYPE>::operator<= (
00296 typename ACE_Atomic_Op<ACE_LOCK, TYPE>::arg_type rhs) const
00297 {
00298 return this->impl_ <= rhs;
00299 }
00300
00301 template <class ACE_LOCK, class TYPE>
00302 ACE_INLINE bool
00303 ACE_Atomic_Op<ACE_LOCK, TYPE>::operator< (
00304 typename ACE_Atomic_Op<ACE_LOCK, TYPE>::arg_type rhs) const
00305 {
00306 return this->impl_ < rhs;
00307 }
00308
00309 template <class ACE_LOCK, class TYPE>
00310 ACE_INLINE TYPE
00311 ACE_Atomic_Op<ACE_LOCK, TYPE>::value (void) const
00312 {
00313 return this->impl_.value ();
00314 }
00315
00316 template <class ACE_LOCK, class TYPE>
00317 ACE_INLINE void
00318 ACE_Atomic_Op<ACE_LOCK, TYPE>::dump (void) const
00319 {
00320 #if defined (ACE_HAS_DUMP)
00321 this->impl_.dump ();
00322 #endif
00323 return;
00324 }
00325
00326 template <class ACE_LOCK, class TYPE>
00327 ACE_INLINE ACE_LOCK &
00328 ACE_Atomic_Op<ACE_LOCK, TYPE>::mutex (void)
00329 {
00330 return this->own_mutex_;
00331 }
00332
00333 template <class ACE_LOCK, class TYPE>
00334 ACE_INLINE TYPE &
00335 ACE_Atomic_Op<ACE_LOCK, TYPE>::value_i (void)
00336 {
00337 return this->impl_.value_i ();
00338 }
00339
00340 ACE_END_VERSIONED_NAMESPACE_DECL