00001
00002
00003
00004
00005 #if defined (ACE_HAS_INTRINSIC_INTERLOCKED)
00006 # include "ace/os_include/os_intrin.h"
00007 # pragma intrinsic (_InterlockedExchange, _InterlockedExchangeAdd, _InterlockedIncrement, _InterlockedDecrement)
00008 #endif
00009
00010 #if defined (ACE_HAS_VXATOMICLIB)
00011 # include <vxAtomicLib.h>
00012 #endif
00013
00014 #if defined (ACE_HAS_SOLARIS_ATOMIC_LIB)
00015 # include <atomic.h>
00016 #endif
00017
00018 ACE_BEGIN_VERSIONED_NAMESPACE_DECL
00019
00020 #if defined (ACE_HAS_BUILTIN_ATOMIC_OP)
00021
00022 ACE_INLINE
00023 ACE_Atomic_Op<ACE_Thread_Mutex, long>::ACE_Atomic_Op (void)
00024 : value_ (0)
00025 {
00026 }
00027
00028 ACE_INLINE
00029 ACE_Atomic_Op<ACE_Thread_Mutex, long>::ACE_Atomic_Op (long c)
00030 : value_ (c)
00031 {
00032 }
00033
00034 ACE_INLINE
00035 ACE_Atomic_Op<ACE_Thread_Mutex, long>::ACE_Atomic_Op (
00036 const ACE_Atomic_Op<ACE_Thread_Mutex, long> &rhs)
00037 : value_ (rhs.value_)
00038 {
00039 }
00040
00041 ACE_INLINE long
00042 ACE_Atomic_Op<ACE_Thread_Mutex, long>::operator++ (void)
00043 {
00044 #if defined (ACE_HAS_INTRINSIC_INTERLOCKED)
00045 return ::_InterlockedIncrement (const_cast<long *> (&this->value_));
00046 #elif defined (WIN32)
00047 return ::InterlockedIncrement (const_cast<long *> (&this->value_));
00048 #elif defined (ACE_HAS_VXATOMICLIB)
00049 return ::vxAtomicInc (reinterpret_cast <atomic_t*>(const_cast<long *> (&this->value_))) + 1;
00050 #elif defined (ACE_HAS_SOLARIS_ATOMIC_LIB)
00051 return ::atomic_inc_ulong_nv (reinterpret_cast<volatile unsigned long*>(&this->value_));
00052 #else
00053 return (*increment_fn_) (&this->value_);
00054 #endif
00055 }
00056
00057 ACE_INLINE long
00058 ACE_Atomic_Op<ACE_Thread_Mutex, long>::operator++ (int)
00059 {
00060 return ++*this - 1;
00061 }
00062
00063 ACE_INLINE long
00064 ACE_Atomic_Op<ACE_Thread_Mutex, long>::operator-- (void)
00065 {
00066 #if defined (ACE_HAS_INTRINSIC_INTERLOCKED)
00067 return ::_InterlockedDecrement (const_cast<long *> (&this->value_));
00068 #elif defined (WIN32)
00069 return ::InterlockedDecrement (const_cast<long *> (&this->value_));
00070 #elif defined (ACE_HAS_VXATOMICLIB)
00071 return ::vxAtomicDec (reinterpret_cast <atomic_t*>(const_cast<long *> (&this->value_))) - 1;
00072 #elif defined (ACE_HAS_SOLARIS_ATOMIC_LIB)
00073 return ::atomic_dec_ulong_nv (reinterpret_cast<volatile unsigned long*>(&this->value_));
00074 #else
00075 return (*decrement_fn_) (&this->value_);
00076 #endif
00077 }
00078
00079 ACE_INLINE long
00080 ACE_Atomic_Op<ACE_Thread_Mutex, long>::operator-- (int)
00081 {
00082 return --*this + 1;
00083 }
00084
00085 ACE_INLINE long
00086 ACE_Atomic_Op<ACE_Thread_Mutex, long>::operator+= (long rhs)
00087 {
00088 #if defined (ACE_HAS_INTRINSIC_INTERLOCKED)
00089 return ::_InterlockedExchangeAdd (const_cast<long *> (&this->value_),
00090 rhs) + rhs;
00091 #elif defined (WIN32) && defined (ACE_HAS_INTERLOCKED_EXCHANGEADD)
00092 return ::InterlockedExchangeAdd (const_cast<long *> (&this->value_),
00093 rhs) + rhs;
00094 #elif defined (ACE_HAS_VXATOMICLIB)
00095 return ::vxAtomicAdd (reinterpret_cast <atomic_t*>(const_cast<long *> (&this->value_)), rhs) + rhs;
00096 #elif defined (ACE_HAS_SOLARIS_ATOMIC_LIB)
00097 return ::atomic_add_long_nv (reinterpret_cast<volatile unsigned long*>(&this->value_), rhs);
00098 #else
00099 return (*exchange_add_fn_) (&this->value_, rhs) + rhs;
00100 #endif
00101 }
00102
00103 ACE_INLINE long
00104 ACE_Atomic_Op<ACE_Thread_Mutex, long>::operator-= (long rhs)
00105 {
00106 #if defined (ACE_HAS_INTRINSIC_INTERLOCKED)
00107 return ::_InterlockedExchangeAdd (const_cast<long *> (&this->value_),
00108 -rhs) - rhs;
00109 #elif defined (WIN32) && defined (ACE_HAS_INTERLOCKED_EXCHANGEADD)
00110 return ::InterlockedExchangeAdd (const_cast<long *> (&this->value_),
00111 -rhs) - rhs;
00112 #elif defined (ACE_HAS_VXATOMICLIB)
00113 return ::vxAtomicSub (reinterpret_cast <atomic_t*>(const_cast<long *> (&this->value_)), rhs) - rhs;
00114 #elif defined (ACE_HAS_SOLARIS_ATOMIC_LIB)
00115 return ::atomic_add_long_nv (reinterpret_cast<volatile unsigned long*>(&this->value_), -rhs);
00116 #else
00117 return (*exchange_add_fn_) (&this->value_, -rhs) - rhs;
00118 #endif
00119 }
00120
00121 ACE_INLINE bool
00122 ACE_Atomic_Op<ACE_Thread_Mutex, long>::operator== (long rhs) const
00123 {
00124 return (this->value_ == rhs);
00125 }
00126
00127 ACE_INLINE bool
00128 ACE_Atomic_Op<ACE_Thread_Mutex, long>::operator!= (long rhs) const
00129 {
00130 return (this->value_ != rhs);
00131 }
00132
00133 ACE_INLINE bool
00134 ACE_Atomic_Op<ACE_Thread_Mutex, long>::operator>= (long rhs) const
00135 {
00136 return (this->value_ >= rhs);
00137 }
00138
00139 ACE_INLINE bool
00140 ACE_Atomic_Op<ACE_Thread_Mutex, long>::operator> (long rhs) const
00141 {
00142 return (this->value_ > rhs);
00143 }
00144
00145 ACE_INLINE bool
00146 ACE_Atomic_Op<ACE_Thread_Mutex, long>::operator<= (long rhs) const
00147 {
00148 return (this->value_ <= rhs);
00149 }
00150
00151 ACE_INLINE bool
00152 ACE_Atomic_Op<ACE_Thread_Mutex, long>::operator< (long rhs) const
00153 {
00154 return (this->value_ < rhs);
00155 }
00156
00157 ACE_INLINE ACE_Atomic_Op<ACE_Thread_Mutex, long> &
00158 ACE_Atomic_Op<ACE_Thread_Mutex, long>::operator= (long rhs)
00159 {
00160 #if defined (ACE_HAS_INTRINSIC_INTERLOCKED)
00161 ::_InterlockedExchange (const_cast<long *> (&this->value_), rhs);
00162 #elif defined (WIN32)
00163 ::InterlockedExchange (const_cast<long *> (&this->value_), rhs);
00164 #elif defined (ACE_HAS_VXATOMICLIB)
00165 ::vxAtomicSet (reinterpret_cast <atomic_t*>(const_cast<long *> (&this->value_)), rhs);
00166 #elif defined (ACE_HAS_SOLARIS_ATOMIC_LIB)
00167 ::atomic_swap_ulong (reinterpret_cast<volatile unsigned long*>(&this->value_), rhs);
00168 #else
00169 (*exchange_fn_) (&this->value_, rhs);
00170 #endif
00171 return *this;
00172 }
00173
00174 ACE_INLINE ACE_Atomic_Op<ACE_Thread_Mutex, long> &
00175 ACE_Atomic_Op<ACE_Thread_Mutex, long>::operator= (
00176 const ACE_Atomic_Op<ACE_Thread_Mutex, long> &rhs)
00177 {
00178 #if defined (ACE_HAS_INTRINSIC_INTERLOCKED)
00179 ::_InterlockedExchange (const_cast<long *> (&this->value_), rhs.value_);
00180 #elif defined (WIN32)
00181 ::InterlockedExchange (const_cast<long *> (&this->value_), rhs.value_);
00182 #elif defined (ACE_HAS_VXATOMICLIB)
00183 ::vxAtomicSet (reinterpret_cast <atomic_t*>(const_cast<long *> (&this->value_)), rhs.value_);
00184 #elif defined (ACE_HAS_SOLARIS_ATOMIC_LIB)
00185 ::atomic_swap_ulong (reinterpret_cast<volatile unsigned long*>(&this->value_), rhs.value_);
00186 #else
00187 (*exchange_fn_) (&this->value_, rhs.value_);
00188 #endif
00189 return *this;
00190 }
00191
00192 ACE_INLINE long
00193 ACE_Atomic_Op<ACE_Thread_Mutex, long>::value (void) const
00194 {
00195 return this->value_;
00196 }
00197
00198 ACE_INLINE volatile long &
00199 ACE_Atomic_Op<ACE_Thread_Mutex, long>::value_i (void)
00200 {
00201 return this->value_;
00202 }
00203
00204
00205 ACE_INLINE
00206 ACE_Atomic_Op<ACE_Thread_Mutex, unsigned long>::ACE_Atomic_Op (void)
00207 : value_ (0)
00208 {
00209 }
00210
00211 ACE_INLINE
00212 ACE_Atomic_Op<ACE_Thread_Mutex, unsigned long>::ACE_Atomic_Op (unsigned long c)
00213 : value_ (c)
00214 {
00215 }
00216
00217 ACE_INLINE
00218 ACE_Atomic_Op<ACE_Thread_Mutex, unsigned long>::ACE_Atomic_Op (
00219 const ACE_Atomic_Op<ACE_Thread_Mutex, unsigned long> &rhs)
00220 : value_ (rhs.value_)
00221 {
00222 }
00223
00224 ACE_INLINE unsigned long
00225 ACE_Atomic_Op<ACE_Thread_Mutex, unsigned long>::operator++ (void)
00226 {
00227 #if defined (ACE_HAS_INTRINSIC_INTERLOCKED)
00228 return static_cast<unsigned long> (::_InterlockedIncrement (const_cast<long *> (reinterpret_cast<volatile long *>(&this->value_))));
00229 #elif defined (WIN32)
00230 return static_cast<unsigned long> (::InterlockedIncrement (const_cast<long *> (reinterpret_cast<volatile long *>(&this->value_))));
00231 #elif defined (ACE_HAS_VXATOMICLIB)
00232 return static_cast<unsigned long> (::vxAtomicInc (reinterpret_cast <atomic_t*>(const_cast<long *> (reinterpret_cast<volatile long *>(&this->value_))))) + 1;
00233 #elif defined (ACE_HAS_SOLARIS_ATOMIC_LIB)
00234 return ::atomic_inc_ulong_nv (&this->value_);
00235 #else
00236 return static_cast<unsigned long> ((*increment_fn_) (reinterpret_cast<volatile long *> (&this->value_)));
00237 #endif
00238 }
00239
00240 ACE_INLINE unsigned long
00241 ACE_Atomic_Op<ACE_Thread_Mutex, unsigned long>::operator++ (int)
00242 {
00243 return ++*this - 1;
00244 }
00245
00246 ACE_INLINE unsigned long
00247 ACE_Atomic_Op<ACE_Thread_Mutex, unsigned long>::operator-- (void)
00248 {
00249 #if defined (ACE_HAS_INTRINSIC_INTERLOCKED)
00250 return static_cast<unsigned long> (::_InterlockedDecrement (const_cast<long *> (reinterpret_cast<volatile long *>(&this->value_))));
00251 #elif defined (WIN32)
00252 return static_cast<unsigned long> (::InterlockedDecrement (const_cast<long *> (reinterpret_cast<volatile long *>(&this->value_))));
00253 #elif defined (ACE_HAS_VXATOMICLIB)
00254 return static_cast<unsigned long> (::vxAtomicDec (reinterpret_cast <atomic_t*>(const_cast<long *> (reinterpret_cast<volatile long *>(&this->value_))))) - 1;
00255 #elif defined (ACE_HAS_SOLARIS_ATOMIC_LIB)
00256 return ::atomic_dec_ulong_nv (&this->value_);
00257 #else
00258 return static_cast<unsigned long> ((*decrement_fn_) (reinterpret_cast<volatile long *> (&this->value_)));
00259 #endif
00260 }
00261
00262 ACE_INLINE unsigned long
00263 ACE_Atomic_Op<ACE_Thread_Mutex, unsigned long>::operator-- (int)
00264 {
00265 return --*this + 1;
00266 }
00267
00268 ACE_INLINE unsigned long
00269 ACE_Atomic_Op<ACE_Thread_Mutex, unsigned long>::operator+= (unsigned long rhs)
00270 {
00271 #if defined (ACE_HAS_INTRINSIC_INTERLOCKED)
00272 return static_cast<unsigned long> (::_InterlockedExchangeAdd (const_cast<long *> (reinterpret_cast <volatile long *>(&this->value_)),
00273 rhs)) + rhs;
00274 #elif defined (WIN32) && defined (ACE_HAS_INTERLOCKED_EXCHANGEADD)
00275 return static_cast<unsigned long> (::InterlockedExchangeAdd (const_cast<long *> (reinterpret_cast <volatile long *>(&this->value_)),
00276 rhs)) + rhs;
00277 #elif defined (ACE_HAS_VXATOMICLIB)
00278 return static_cast<unsigned long> (::vxAtomicAdd (reinterpret_cast <atomic_t*>(const_cast<long *> (reinterpret_cast<volatile long *>(&this->value_))), rhs)) + rhs;
00279 #elif defined (ACE_HAS_SOLARIS_ATOMIC_LIB)
00280 return ::atomic_add_long_nv (&this->value_, rhs);
00281 #else
00282 return static_cast<unsigned long> ((*exchange_add_fn_) (reinterpret_cast<volatile long *> (&this->value_), rhs)) + rhs;
00283 #endif
00284 }
00285
00286 ACE_INLINE unsigned long
00287 ACE_Atomic_Op<ACE_Thread_Mutex, unsigned long>::operator-= (unsigned long rhs)
00288 {
00289 #if defined (ACE_HAS_INTRINSIC_INTERLOCKED)
00290 return static_cast<unsigned long> (::_InterlockedExchangeAdd (const_cast<long *> (reinterpret_cast<volatile long *>(&this->value_)),
00291 -static_cast<long>(rhs))) - rhs;
00292 #elif defined (WIN32) && defined (ACE_HAS_INTERLOCKED_EXCHANGEADD)
00293 return static_cast<unsigned long> (::InterlockedExchangeAdd (const_cast<long *> (reinterpret_cast<volatile long *>(&this->value_)),
00294 -static_cast<long>(rhs))) - rhs;
00295 #elif defined (ACE_HAS_VXATOMICLIB)
00296 return static_cast<unsigned long> (::vxAtomicSub (reinterpret_cast <atomic_t*>(const_cast<long *> (reinterpret_cast<volatile long *>(&this->value_))), rhs)) - rhs;
00297 #elif defined (ACE_HAS_SOLARIS_ATOMIC_LIB)
00298 return ::atomic_add_long_nv (&this->value_, -rhs);
00299 #else
00300 long l_rhs = static_cast<long> (rhs);
00301 return static_cast<unsigned long> ((*exchange_add_fn_) (reinterpret_cast<volatile long *> (&this->value_), -l_rhs)) - rhs;
00302 #endif
00303 }
00304
00305 ACE_INLINE bool
00306 ACE_Atomic_Op<ACE_Thread_Mutex, unsigned long>::operator== (unsigned long rhs) const
00307 {
00308 return (this->value_ == rhs);
00309 }
00310
00311 ACE_INLINE bool
00312 ACE_Atomic_Op<ACE_Thread_Mutex, unsigned long>::operator!= (unsigned long rhs) const
00313 {
00314 return (this->value_ != rhs);
00315 }
00316
00317 ACE_INLINE bool
00318 ACE_Atomic_Op<ACE_Thread_Mutex, unsigned long>::operator>= (unsigned long rhs) const
00319 {
00320 return (this->value_ >= rhs);
00321 }
00322
00323 ACE_INLINE bool
00324 ACE_Atomic_Op<ACE_Thread_Mutex, unsigned long>::operator> (unsigned long rhs) const
00325 {
00326 return (this->value_ > rhs);
00327 }
00328
00329 ACE_INLINE bool
00330 ACE_Atomic_Op<ACE_Thread_Mutex, unsigned long>::operator<= (unsigned long rhs) const
00331 {
00332 return (this->value_ <= rhs);
00333 }
00334
00335 ACE_INLINE bool
00336 ACE_Atomic_Op<ACE_Thread_Mutex, unsigned long>::operator< (unsigned long rhs) const
00337 {
00338 return (this->value_ < rhs);
00339 }
00340
00341 ACE_INLINE ACE_Atomic_Op<ACE_Thread_Mutex, unsigned long> &
00342 ACE_Atomic_Op<ACE_Thread_Mutex, unsigned long>::operator= (unsigned long rhs)
00343 {
00344 #if defined (ACE_HAS_INTRINSIC_INTERLOCKED)
00345 ::_InterlockedExchange (const_cast<long *> (reinterpret_cast<volatile long*> (&this->value_)), rhs);
00346 #elif defined (WIN32)
00347 ::InterlockedExchange (const_cast<long *> (reinterpret_cast<volatile long*> (&this->value_)), rhs);
00348 #elif defined (ACE_HAS_VXATOMICLIB)
00349 ::vxAtomicSet (reinterpret_cast <atomic_t*>(const_cast<long *> (reinterpret_cast<volatile long*> (&this->value_))), rhs);
00350 #elif defined (ACE_HAS_SOLARIS_ATOMIC_LIB)
00351 ::atomic_swap_ulong (&this->value_, rhs);
00352 #else
00353 (*exchange_fn_) (reinterpret_cast<volatile long *> (&this->value_), rhs);
00354 #endif
00355 return *this;
00356 }
00357
00358 ACE_INLINE ACE_Atomic_Op<ACE_Thread_Mutex, unsigned long> &
00359 ACE_Atomic_Op<ACE_Thread_Mutex, unsigned long>::operator= (
00360 const ACE_Atomic_Op<ACE_Thread_Mutex, unsigned long> &rhs)
00361 {
00362 #if defined (ACE_HAS_INTRINSIC_INTERLOCKED)
00363 ::_InterlockedExchange (const_cast<long *> (reinterpret_cast<volatile long*> (&this->value_)), rhs.value_);
00364 #elif defined (WIN32)
00365 ::InterlockedExchange (const_cast<long *> (reinterpret_cast<volatile long*> (&this->value_)), rhs.value_);
00366 #elif defined (ACE_HAS_VXATOMICLIB)
00367 ::vxAtomicSet (reinterpret_cast <atomic_t*>(const_cast<long *> (reinterpret_cast<volatile long*> (&this->value_))), rhs.value_);
00368 #elif defined (ACE_HAS_SOLARIS_ATOMIC_LIB)
00369 ::atomic_swap_ulong (&this->value_, rhs.value_);
00370 #else
00371 (*exchange_fn_) (reinterpret_cast<volatile long *> (&this->value_), rhs.value_);
00372 #endif
00373 return *this;
00374 }
00375
00376 ACE_INLINE unsigned long
00377 ACE_Atomic_Op<ACE_Thread_Mutex, unsigned long>::value (void) const
00378 {
00379 return this->value_;
00380 }
00381
00382 ACE_INLINE volatile unsigned long &
00383 ACE_Atomic_Op<ACE_Thread_Mutex, unsigned long>::value_i (void)
00384 {
00385 return this->value_;
00386 }
00387
00388 #endif
00389
00390 #if defined (ACE_HAS_GCC_ATOMIC_BUILTINS) && (ACE_HAS_GCC_ATOMIC_BUILTINS == 1)
00391
00392 ACE_INLINE
00393 ACE_Atomic_Op<ACE_Thread_Mutex, int>::ACE_Atomic_Op (void) :
00394 ACE_Atomic_Op_GCC<int> ()
00395 {
00396 }
00397
00398 ACE_INLINE
00399 ACE_Atomic_Op<ACE_Thread_Mutex, int>::ACE_Atomic_Op (int c) :
00400 ACE_Atomic_Op_GCC<int>(c)
00401 {
00402 }
00403
00404 ACE_INLINE
00405 ACE_Atomic_Op<ACE_Thread_Mutex, int>::ACE_Atomic_Op (const ACE_Atomic_Op<ACE_Thread_Mutex, int> &c) :
00406 ACE_Atomic_Op_GCC<int>(c)
00407 {
00408 }
00409
00410 ACE_INLINE
00411 ACE_Atomic_Op<ACE_Thread_Mutex, int>&
00412 ACE_Atomic_Op<ACE_Thread_Mutex, int>::operator= (int rhs)
00413 {
00414 ACE_Atomic_Op_GCC<int>::operator= (rhs);
00415 return *this;
00416 }
00417
00418
00419 ACE_INLINE
00420 ACE_Atomic_Op<ACE_Thread_Mutex, unsigned int>::ACE_Atomic_Op (void) :
00421 ACE_Atomic_Op_GCC<unsigned int>()
00422 {
00423 }
00424
00425 ACE_INLINE
00426 ACE_Atomic_Op<ACE_Thread_Mutex, unsigned int>::ACE_Atomic_Op (const ACE_Atomic_Op<ACE_Thread_Mutex, unsigned int> &c) :
00427 ACE_Atomic_Op_GCC<unsigned int>(c)
00428 {
00429 }
00430
00431 ACE_INLINE
00432 ACE_Atomic_Op<ACE_Thread_Mutex, unsigned int>::ACE_Atomic_Op (unsigned int c) :
00433 ACE_Atomic_Op_GCC<unsigned int>(c)
00434 {
00435 }
00436
00437 ACE_INLINE
00438 ACE_Atomic_Op<ACE_Thread_Mutex, unsigned int>&
00439 ACE_Atomic_Op<ACE_Thread_Mutex, unsigned int>::operator= (unsigned int rhs)
00440 {
00441 ACE_Atomic_Op_GCC<unsigned int>::operator= (rhs);
00442 return *this;
00443 }
00444
00445 ACE_INLINE
00446 ACE_Atomic_Op<ACE_Thread_Mutex, long>::ACE_Atomic_Op (void) :
00447 ACE_Atomic_Op_GCC<long>()
00448 {
00449 }
00450
00451 ACE_INLINE
00452 ACE_Atomic_Op<ACE_Thread_Mutex, long>::ACE_Atomic_Op (long c) :
00453 ACE_Atomic_Op_GCC<long>(c)
00454 {
00455 }
00456
00457 ACE_INLINE
00458 ACE_Atomic_Op<ACE_Thread_Mutex, long>::ACE_Atomic_Op (const ACE_Atomic_Op<ACE_Thread_Mutex, long> &c) :
00459 ACE_Atomic_Op_GCC<long>(c)
00460 {
00461 }
00462
00463 ACE_INLINE
00464 ACE_Atomic_Op<ACE_Thread_Mutex, long>&
00465 ACE_Atomic_Op<ACE_Thread_Mutex, long>::operator= (long rhs)
00466 {
00467 ACE_Atomic_Op_GCC<long>::operator= (rhs);
00468 return *this;
00469 }
00470
00471 ACE_INLINE
00472 ACE_Atomic_Op<ACE_Thread_Mutex, unsigned long>::ACE_Atomic_Op (void) :
00473 ACE_Atomic_Op_GCC<unsigned long> ()
00474 {
00475 }
00476
00477 ACE_INLINE
00478 ACE_Atomic_Op<ACE_Thread_Mutex, unsigned long>::ACE_Atomic_Op (unsigned long c) :
00479 ACE_Atomic_Op_GCC<unsigned long>(c)
00480 {
00481 }
00482
00483 ACE_INLINE
00484 ACE_Atomic_Op<ACE_Thread_Mutex, unsigned long>::ACE_Atomic_Op (const ACE_Atomic_Op<ACE_Thread_Mutex, unsigned long> &c) :
00485 ACE_Atomic_Op_GCC<unsigned long>(c)
00486 {
00487 }
00488
00489 ACE_INLINE
00490 ACE_Atomic_Op<ACE_Thread_Mutex, unsigned long>&
00491 ACE_Atomic_Op<ACE_Thread_Mutex, unsigned long>::operator= (unsigned long rhs)
00492 {
00493 ACE_Atomic_Op_GCC<unsigned long>::operator= (rhs);
00494 return *this;
00495 }
00496
00497 #if !defined (ACE_LACKS_GCC_ATOMIC_BUILTINS_2)
00498 ACE_INLINE
00499 ACE_Atomic_Op<ACE_Thread_Mutex, short>::ACE_Atomic_Op (void) :
00500 ACE_Atomic_Op_GCC<short>()
00501 {
00502 }
00503
00504 ACE_INLINE
00505 ACE_Atomic_Op<ACE_Thread_Mutex, short>::ACE_Atomic_Op (short c) :
00506 ACE_Atomic_Op_GCC<short>(c)
00507 {
00508 }
00509
00510 ACE_INLINE
00511 ACE_Atomic_Op<ACE_Thread_Mutex, short>::ACE_Atomic_Op (const ACE_Atomic_Op<ACE_Thread_Mutex, short> &c) :
00512 ACE_Atomic_Op_GCC<short>(c)
00513 {
00514 }
00515
00516 ACE_INLINE
00517 ACE_Atomic_Op<ACE_Thread_Mutex, short>&
00518 ACE_Atomic_Op<ACE_Thread_Mutex, short>::operator= (short rhs)
00519 {
00520 ACE_Atomic_Op_GCC<short>::operator= (rhs);
00521 return *this;
00522 }
00523
00524 ACE_INLINE
00525 ACE_Atomic_Op<ACE_Thread_Mutex, unsigned short>::ACE_Atomic_Op (void) :
00526 ACE_Atomic_Op_GCC<unsigned short> ()
00527 {
00528 }
00529
00530 ACE_INLINE
00531 ACE_Atomic_Op<ACE_Thread_Mutex, unsigned short>::ACE_Atomic_Op (unsigned short c) :
00532 ACE_Atomic_Op_GCC<unsigned short>(c)
00533 {
00534 }
00535
00536 ACE_INLINE
00537 ACE_Atomic_Op<ACE_Thread_Mutex, unsigned short>::ACE_Atomic_Op (const ACE_Atomic_Op<ACE_Thread_Mutex, unsigned short> &c) :
00538 ACE_Atomic_Op_GCC<unsigned short>(c)
00539 {
00540 }
00541
00542 ACE_INLINE
00543 ACE_Atomic_Op<ACE_Thread_Mutex, unsigned short>&
00544 ACE_Atomic_Op<ACE_Thread_Mutex, unsigned short>::operator= (unsigned short rhs)
00545 {
00546 ACE_Atomic_Op_GCC<unsigned short>::operator= (rhs);
00547 return *this;
00548 }
00549 #endif
00550
00551 #if !defined (ACE_LACKS_GCC_ATOMIC_BUILTINS_1)
00552 ACE_INLINE
00553 ACE_Atomic_Op<ACE_Thread_Mutex, bool>::ACE_Atomic_Op (void) :
00554 ACE_Atomic_Op_GCC<bool> ()
00555 {
00556 }
00557
00558 ACE_INLINE
00559 ACE_Atomic_Op<ACE_Thread_Mutex, bool>::ACE_Atomic_Op (bool c) :
00560 ACE_Atomic_Op_GCC<bool>(c)
00561 {
00562 }
00563
00564 ACE_INLINE
00565 ACE_Atomic_Op<ACE_Thread_Mutex, bool>::ACE_Atomic_Op (const ACE_Atomic_Op<ACE_Thread_Mutex, bool> &c) :
00566 ACE_Atomic_Op_GCC<bool>(c)
00567 {
00568 }
00569
00570 ACE_INLINE
00571 ACE_Atomic_Op<ACE_Thread_Mutex, bool>&
00572 ACE_Atomic_Op<ACE_Thread_Mutex, bool>::operator= (bool rhs)
00573 {
00574 ACE_Atomic_Op_GCC<bool>::operator= (rhs);
00575 return *this;
00576 }
00577 #endif
00578
00579 #endif
00580
00581 ACE_END_VERSIONED_NAMESPACE_DECL
00582