ACE: Atomic_Op_T.inl Source File

00001 // -*- C++ -*-
00002 //
00003 // $Id: Atomic_Op_T.inl 80826 2008-03-04 14:51:23Z wotte $
00004 
00005 #include "ace/Guard_T.h"
00006 
00007 #include <algorithm>
00008 
00009 ACE_BEGIN_VERSIONED_NAMESPACE_DECL
00010 
00011 //
00012 // ACE_Atomic_Op_Ex inline functions
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   // ACE_TRACE ("ACE_Atomic_Op_Ex<ACE_LOCK, TYPE>::operator++");
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   // ACE_TRACE ("ACE_Atomic_Op_Ex<ACE_LOCK, TYPE>::operator+=");
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   // ACE_TRACE ("ACE_Atomic_Op_Ex<ACE_LOCK, TYPE>::operator--");
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   // ACE_TRACE ("ACE_Atomic_Op_Ex<ACE_LOCK, TYPE>::operator-=");
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 ())  // rhs.value() returns atomically
00059 {
00060   // ACE_TRACE ("ACE_Atomic_Op_Ex<ACE_LOCK, TYPE>::ACE_Atomic_Op_Ex");
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   // ACE_TRACE ("ACE_Atomic_Op_Ex<ACE_LOCK, TYPE>::operator++");
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   // ACE_TRACE ("ACE_Atomic_Op_Ex<ACE_LOCK, TYPE>::operator--");
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   // ACE_TRACE ("ACE_Atomic_Op_Ex<ACE_LOCK, TYPE>::operator==");
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   // ACE_TRACE ("ACE_Atomic_Op_Ex<ACE_LOCK, TYPE>::operator!=");
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   // ACE_TRACE ("ACE_Atomic_Op_Ex<ACE_LOCK, TYPE>::operator>=");
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   // ACE_TRACE ("ACE_Atomic_Op_Ex<ACE_LOCK, TYPE>::operator>");
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   // ACE_TRACE ("ACE_Atomic_Op_Ex<ACE_LOCK, TYPE>::operator<=");
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   // ACE_TRACE ("ACE_Atomic_Op_Ex<ACE_LOCK, TYPE>::operator<");
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   // ACE_TRACE ("ACE_Atomic_Op_Ex<ACE_LOCK, TYPE>::operator=");
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   // ACE_TRACE ("ACE_Atomic_Op_Ex<ACE_LOCK, TYPE>::value");
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   // Explicitly return <value_> (by reference).  This gives the user
00169   // full, unrestricted access to the underlying value.  This method
00170   // will usually be used in conjunction with explicit access to the
00171   // lock.  Use with care ;-)
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   // ACE_TRACE ("ACE_Atomic_Op_Ex<ACE_LOCK, TYPE>::operator=");
00181   ACE_GUARD_RETURN (ACE_LOCK, ace_mon, this->mutex_, *this);
00182   this->value_ = rhs;
00183   return *this;
00184 }
00185 
00186 //
00187 // ACE_Atomic_Op inline functions
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   // ACE_TRACE ("ACE_Atomic_Op<ACE_LOCK, TYPE>::ACE_Atomic_Op");
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 /* ACE_HAS_DUMP */
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