dep/ACE_wrappers/ace/Atomic_Op_T.inl

   1 // -*- C++ -*-
   2 //
   3 // $Id: Atomic_Op_T.inl 80826 2008-03-04 14:51:23Z wotte $
   4
   5 #include "ace/Guard_T.h"
   6
   7 #include <algorithm>
   8
   9 ACE_BEGIN_VERSIONED_NAMESPACE_DECL
  10
  11 //
  12 // ACE_Atomic_Op_Ex inline functions
  13 //
  14
  15 template <class ACE_LOCK, class TYPE>
  16 ACE_INLINE TYPE
  17 ACE_Atomic_Op_Ex<ACE_LOCK, TYPE>::operator++ (void)
  18 {
  19   // ACE_TRACE ("ACE_Atomic_Op_Ex<ACE_LOCK, TYPE>::operator++");
  20   ACE_GUARD_RETURN (ACE_LOCK, ace_mon, this->mutex_, this->value_);
  21   return ++this->value_;
  22 }
  23
  24 template <class ACE_LOCK, class TYPE>
  25 ACE_INLINE TYPE
  26 ACE_Atomic_Op_Ex<ACE_LOCK, TYPE>::operator+= (
  27   typename ACE_Atomic_Op_Ex<ACE_LOCK, TYPE>::arg_type rhs)
  28 {
  29   // ACE_TRACE ("ACE_Atomic_Op_Ex<ACE_LOCK, TYPE>::operator+=");
  30   ACE_GUARD_RETURN (ACE_LOCK, ace_mon, this->mutex_, this->value_);
  31   return this->value_ += rhs;
  32 }
  33
  34 template <class ACE_LOCK, class TYPE>
  35 ACE_INLINE TYPE
  36 ACE_Atomic_Op_Ex<ACE_LOCK, TYPE>::operator-- (void)
  37 {
  38   // ACE_TRACE ("ACE_Atomic_Op_Ex<ACE_LOCK, TYPE>::operator--");
  39   ACE_GUARD_RETURN (ACE_LOCK, ace_mon, this->mutex_, this->value_);
  40   return --this->value_;
  41 }
  42
  43 template <class ACE_LOCK, class TYPE>
  44 ACE_INLINE TYPE
  45 ACE_Atomic_Op_Ex<ACE_LOCK, TYPE>::operator-= (
  46   typename ACE_Atomic_Op_Ex<ACE_LOCK, TYPE>::arg_type rhs)
  47 {
  48   // ACE_TRACE ("ACE_Atomic_Op_Ex<ACE_LOCK, TYPE>::operator-=");
  49   ACE_GUARD_RETURN (ACE_LOCK, ace_mon, this->mutex_, this->value_);
  50   return this->value_ -= rhs;
  51 }
  52
  53 template <class ACE_LOCK, class TYPE>
  54 ACE_INLINE
  55 ACE_Atomic_Op_Ex<ACE_LOCK, TYPE>::ACE_Atomic_Op_Ex (
  56   ACE_Atomic_Op_Ex<ACE_LOCK, TYPE> const & rhs)
  57   : mutex_ (rhs.mutex_)
  58   , value_ (rhs.value ())  // rhs.value() returns atomically
  59 {
  60   // ACE_TRACE ("ACE_Atomic_Op_Ex<ACE_LOCK, TYPE>::ACE_Atomic_Op_Ex");
  61 }
  62
  63 template <class ACE_LOCK, class TYPE>
  64 ACE_INLINE TYPE
  65 ACE_Atomic_Op_Ex<ACE_LOCK, TYPE>::operator++ (int)
  66 {
  67   // ACE_TRACE ("ACE_Atomic_Op_Ex<ACE_LOCK, TYPE>::operator++");
  68   ACE_GUARD_RETURN (ACE_LOCK, ace_mon, this->mutex_, this->value_);
  69   return this->value_++;
  70 }
  71
  72 template <class ACE_LOCK, class TYPE>
  73 ACE_INLINE TYPE
  74 ACE_Atomic_Op_Ex<ACE_LOCK, TYPE>::operator-- (int)
  75 {
  76   // ACE_TRACE ("ACE_Atomic_Op_Ex<ACE_LOCK, TYPE>::operator--");
  77   ACE_GUARD_RETURN (ACE_LOCK, ace_mon, this->mutex_, this->value_);
  78   return this->value_--;
  79 }
  80
  81 template <class ACE_LOCK, class TYPE>
  82 ACE_INLINE bool
  83 ACE_Atomic_Op_Ex<ACE_LOCK, TYPE>::operator== (
  84   typename ACE_Atomic_Op_Ex<ACE_LOCK, TYPE>::arg_type rhs) const
  85 {
  86   // ACE_TRACE ("ACE_Atomic_Op_Ex<ACE_LOCK, TYPE>::operator==");
  87   ACE_GUARD_RETURN (ACE_LOCK, ace_mon, this->mutex_, false);
  88   return this->value_ == rhs;
  89 }
  90
  91 template <class ACE_LOCK, class TYPE>
  92 ACE_INLINE bool
  93 ACE_Atomic_Op_Ex<ACE_LOCK, TYPE>::operator!= (
  94   typename ACE_Atomic_Op_Ex<ACE_LOCK, TYPE>::arg_type rhs) const
  95 {
  96   // ACE_TRACE ("ACE_Atomic_Op_Ex<ACE_LOCK, TYPE>::operator!=");
  97   return !(*this == rhs);
  98 }
  99
 100 template <class ACE_LOCK, class TYPE>
 101 ACE_INLINE bool
 102 ACE_Atomic_Op_Ex<ACE_LOCK, TYPE>::operator>= (
 103   typename ACE_Atomic_Op_Ex<ACE_LOCK, TYPE>::arg_type rhs) const
 104 {
 105   // ACE_TRACE ("ACE_Atomic_Op_Ex<ACE_LOCK, TYPE>::operator>=");
 106   ACE_GUARD_RETURN (ACE_LOCK, ace_mon, this->mutex_, false);
 107   return this->value_ >= rhs;
 108 }
 109
 110 template <class ACE_LOCK, class TYPE>
 111 ACE_INLINE bool
 112 ACE_Atomic_Op_Ex<ACE_LOCK, TYPE>::operator> (
 113   typename ACE_Atomic_Op_Ex<ACE_LOCK, TYPE>::arg_type rhs) const
 114 {
 115   // ACE_TRACE ("ACE_Atomic_Op_Ex<ACE_LOCK, TYPE>::operator>");
 116   ACE_GUARD_RETURN (ACE_LOCK, ace_mon, this->mutex_, false);
 117   return this->value_ > rhs;
 118 }
 119
 120 template <class ACE_LOCK, class TYPE>
 121 ACE_INLINE bool
 122 ACE_Atomic_Op_Ex<ACE_LOCK, TYPE>::operator<= (
 123   typename ACE_Atomic_Op_Ex<ACE_LOCK, TYPE>::arg_type rhs) const
 124 {
 125   // ACE_TRACE ("ACE_Atomic_Op_Ex<ACE_LOCK, TYPE>::operator<=");
 126   ACE_GUARD_RETURN (ACE_LOCK, ace_mon, this->mutex_, false);
 127   return this->value_ <= rhs;
 128 }
 129
 130 template <class ACE_LOCK, class TYPE>
 131 ACE_INLINE bool
 132 ACE_Atomic_Op_Ex<ACE_LOCK, TYPE>::operator< (
 133   typename ACE_Atomic_Op_Ex<ACE_LOCK, TYPE>::arg_type rhs) const
 134 {
 135   // ACE_TRACE ("ACE_Atomic_Op_Ex<ACE_LOCK, TYPE>::operator<");
 136   ACE_GUARD_RETURN (ACE_LOCK, ace_mon, this->mutex_, false);
 137   return this->value_ < rhs;
 138 }
 139
 140 template <class ACE_LOCK, class TYPE>
 141 ACE_INLINE ACE_Atomic_Op_Ex<ACE_LOCK, TYPE> &
 142 ACE_Atomic_Op_Ex<ACE_LOCK, TYPE>::operator= (
 143   ACE_Atomic_Op_Ex<ACE_LOCK, TYPE> const & rhs)
 144 {
 145   // ACE_TRACE ("ACE_Atomic_Op_Ex<ACE_LOCK, TYPE>::operator=");
 146
 147   ACE_Atomic_Op_Ex<ACE_LOCK, TYPE> tmp (rhs);
 148
 149   ACE_GUARD_RETURN (ACE_LOCK, ace_mon, this->mutex_, *this);
 150   std::swap (this->value_, tmp.value_);
 151
 152   return *this;
 153 }
 154
 155 template <class ACE_LOCK, class TYPE>
 156 ACE_INLINE TYPE
 157 ACE_Atomic_Op_Ex<ACE_LOCK, TYPE>::value (void) const
 158 {
 159   // ACE_TRACE ("ACE_Atomic_Op_Ex<ACE_LOCK, TYPE>::value");
 160   ACE_GUARD_RETURN (ACE_LOCK, ace_mon, this->mutex_, this->value_);
 161   return this->value_;
 162 }
 163
 164 template <class ACE_LOCK, class TYPE>
 165 ACE_INLINE TYPE &
 166 ACE_Atomic_Op_Ex<ACE_LOCK, TYPE>::value_i (void)
 167 {
 168   // Explicitly return <value_> (by reference).  This gives the user
 169   // full, unrestricted access to the underlying value.  This method
 170   // will usually be used in conjunction with explicit access to the
 171   // lock.  Use with care ;-)
 172   return this->value_;
 173 }
 174
 175 template <class ACE_LOCK, class TYPE>
 176 ACE_INLINE ACE_Atomic_Op_Ex<ACE_LOCK, TYPE> &
 177 ACE_Atomic_Op_Ex<ACE_LOCK, TYPE>::operator= (
 178   typename ACE_Atomic_Op_Ex<ACE_LOCK, TYPE>::arg_type rhs)
 179 {
 180   // ACE_TRACE ("ACE_Atomic_Op_Ex<ACE_LOCK, TYPE>::operator=");
 181   ACE_GUARD_RETURN (ACE_LOCK, ace_mon, this->mutex_, *this);
 182   this->value_ = rhs;
 183   return *this;
 184 }
 185
 186 //
 187 // ACE_Atomic_Op inline functions
 188 //
 189
 190 template <class ACE_LOCK, class TYPE> ACE_INLINE
 191 ACE_Atomic_Op<ACE_LOCK, TYPE>::ACE_Atomic_Op (
 192   ACE_Atomic_Op<ACE_LOCK, TYPE> const & rhs)
 193   : impl_ (own_mutex_, rhs.value ())
 194 {
 195   // ACE_TRACE ("ACE_Atomic_Op<ACE_LOCK, TYPE>::ACE_Atomic_Op");
 196 }
 197
 198
 199 template <class ACE_LOCK, class TYPE>
 200 ACE_INLINE ACE_Atomic_Op<ACE_LOCK, TYPE> &
 201 ACE_Atomic_Op<ACE_LOCK, TYPE>::operator= (
 202   typename ACE_Atomic_Op<ACE_LOCK, TYPE>::arg_type i)
 203 {
 204   this->impl_ = i;
 205   return *this;
 206 }
 207
 208 template <class ACE_LOCK, class TYPE>
 209 ACE_INLINE ACE_Atomic_Op<ACE_LOCK, TYPE> &
 210 ACE_Atomic_Op<ACE_LOCK, TYPE>::operator= (
 211   ACE_Atomic_Op<ACE_LOCK, TYPE> const & rhs)
 212 {
 213   this->impl_ = rhs.impl_;
 214   return *this;
 215 }
 216
 217 template <class ACE_LOCK, class TYPE>
 218 ACE_INLINE TYPE
 219 ACE_Atomic_Op<ACE_LOCK, TYPE>::operator++ (void)
 220 {
 221   return ++this->impl_;
 222 }
 223
 224 template <class ACE_LOCK, class TYPE>
 225 ACE_INLINE TYPE
 226 ACE_Atomic_Op<ACE_LOCK, TYPE>::operator++ (int)
 227 {
 228   return this->impl_++;
 229 }
 230
 231 template <class ACE_LOCK, class TYPE>
 232 ACE_INLINE TYPE
 233 ACE_Atomic_Op<ACE_LOCK, TYPE>::operator+= (
 234   typename ACE_Atomic_Op<ACE_LOCK, TYPE>::arg_type rhs)
 235 {
 236   return this->impl_ += rhs;
 237 }
 238
 239 template <class ACE_LOCK, class TYPE>
 240 ACE_INLINE TYPE
 241 ACE_Atomic_Op<ACE_LOCK, TYPE>::operator-- (void)
 242 {
 243   return --this->impl_;
 244 }
 245
 246 template <class ACE_LOCK, class TYPE>
 247 ACE_INLINE TYPE
 248 ACE_Atomic_Op<ACE_LOCK, TYPE>::operator-- (int)
 249 {
 250   return this->impl_--;
 251 }
 252
 253 template <class ACE_LOCK, class TYPE>
 254 ACE_INLINE TYPE
 255 ACE_Atomic_Op<ACE_LOCK, TYPE>::operator-= (
 256   typename ACE_Atomic_Op<ACE_LOCK, TYPE>::arg_type rhs)
 257 {
 258   return this->impl_ -= rhs;
 259 }
 260
 261 template <class ACE_LOCK, class TYPE>
 262 ACE_INLINE bool
 263 ACE_Atomic_Op<ACE_LOCK, TYPE>::operator== (
 264   typename ACE_Atomic_Op<ACE_LOCK, TYPE>::arg_type rhs) const
 265 {
 266   return this->impl_ == rhs;
 267 }
 268
 269 template <class ACE_LOCK, class TYPE>
 270 ACE_INLINE bool
 271 ACE_Atomic_Op<ACE_LOCK, TYPE>::operator!= (
 272   typename ACE_Atomic_Op<ACE_LOCK, TYPE>::arg_type rhs) const
 273 {
 274   return this->impl_ != rhs;
 275 }
 276
 277 template <class ACE_LOCK, class TYPE>
 278 ACE_INLINE bool
 279 ACE_Atomic_Op<ACE_LOCK, TYPE>::operator>= (
 280   typename ACE_Atomic_Op<ACE_LOCK, TYPE>::arg_type rhs) const
 281 {
 282   return this->impl_ >= rhs;
 283 }
 284
 285 template <class ACE_LOCK, class TYPE>
 286 ACE_INLINE bool
 287 ACE_Atomic_Op<ACE_LOCK, TYPE>::operator> (
 288   typename ACE_Atomic_Op<ACE_LOCK, TYPE>::arg_type rhs) const
 289 {
 290   return this->impl_ > rhs;
 291 }
 292
 293 template <class ACE_LOCK, class TYPE>
 294 ACE_INLINE bool
 295 ACE_Atomic_Op<ACE_LOCK, TYPE>::operator<= (
 296   typename ACE_Atomic_Op<ACE_LOCK, TYPE>::arg_type rhs) const
 297 {
 298   return this->impl_ <= rhs;
 299 }
 300
 301 template <class ACE_LOCK, class TYPE>
 302 ACE_INLINE bool
 303 ACE_Atomic_Op<ACE_LOCK, TYPE>::operator< (
 304   typename ACE_Atomic_Op<ACE_LOCK, TYPE>::arg_type rhs) const
 305 {
 306   return this->impl_ < rhs;
 307 }
 308
 309 template <class ACE_LOCK, class TYPE>
 310 ACE_INLINE TYPE
 311 ACE_Atomic_Op<ACE_LOCK, TYPE>::value (void) const
 312 {
 313   return this->impl_.value ();
 314 }
 315
 316 template <class ACE_LOCK, class TYPE>
 317 ACE_INLINE void
 318 ACE_Atomic_Op<ACE_LOCK, TYPE>::dump (void) const
 319 {
 320 #if defined (ACE_HAS_DUMP)
 321   this->impl_.dump ();
 322 #endif /* ACE_HAS_DUMP */
 323   return;
 324 }
 325
 326 template <class ACE_LOCK, class TYPE>
 327 ACE_INLINE ACE_LOCK &
 328 ACE_Atomic_Op<ACE_LOCK, TYPE>::mutex (void)
 329 {
 330   return this->own_mutex_;
 331 }
 332
 333 template <class ACE_LOCK, class TYPE>
 334 ACE_INLINE TYPE &
 335 ACE_Atomic_Op<ACE_LOCK, TYPE>::value_i (void)
 336 {
 337   return this->impl_.value_i ();
 338 }
 339
 340 ACE_END_VERSIONED_NAMESPACE_DECL