ACE/ace/Atomic_Op_T.inl

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