qbasicatomic.h
上传用户:detong
上传日期:2022-06-22
资源大小:20675k
文件大小:6k
源码类别:

系统编程

开发平台:

Unix_Linux

  1. /****************************************************************************
  2. **
  3. ** Copyright (C) 2008 Nokia Corporation and/or its subsidiary(-ies).
  4. ** Contact: Qt Software Information (qt-info@nokia.com)
  5. **
  6. ** This file is part of the QtCore module of the Qt Toolkit.
  7. **
  8. ** Commercial Usage
  9. ** Licensees holding valid Qt Commercial licenses may use this file in
  10. ** accordance with the Qt Commercial License Agreement provided with the
  11. ** Software or, alternatively, in accordance with the terms contained in
  12. ** a written agreement between you and Nokia.
  13. **
  14. **
  15. ** GNU General Public License Usage
  16. ** Alternatively, this file may be used under the terms of the GNU
  17. ** General Public License versions 2.0 or 3.0 as published by the Free
  18. ** Software Foundation and appearing in the file LICENSE.GPL included in
  19. ** the packaging of this file.  Please review the following information
  20. ** to ensure GNU General Public Licensing requirements will be met:
  21. ** http://www.fsf.org/licensing/licenses/info/GPLv2.html and
  22. ** http://www.gnu.org/copyleft/gpl.html.  In addition, as a special
  23. ** exception, Nokia gives you certain additional rights. These rights
  24. ** are described in the Nokia Qt GPL Exception version 1.3, included in
  25. ** the file GPL_EXCEPTION.txt in this package.
  26. **
  27. ** Qt for Windows(R) Licensees
  28. ** As a special exception, Nokia, as the sole copyright holder for Qt
  29. ** Designer, grants users of the Qt/Eclipse Integration plug-in the
  30. ** right for the Qt/Eclipse Integration to link to functionality
  31. ** provided by Qt Designer and its related libraries.
  32. **
  33. ** If you are unsure which license is appropriate for your use, please
  34. ** contact the sales department at qt-sales@nokia.com.
  35. **
  36. ****************************************************************************/
  37. #ifndef QBASICATOMIC_H
  38. #define QBASICATOMIC_H
  39. #include <QtCore/qglobal.h>
  40. QT_BEGIN_HEADER
  41. QT_BEGIN_NAMESPACE
  42. QT_MODULE(Core)
  43. class Q_CORE_EXPORT QBasicAtomicInt
  44. {
  45. public:
  46. #ifdef QT_ARCH_PARISC
  47.     int _q_lock[4];
  48. #endif
  49.     volatile int _q_value;
  50.     // Non-atomic API
  51.     inline bool operator==(int value) const
  52.     {
  53.         return _q_value == value;
  54.     }
  55.     inline bool operator!=(int value) const
  56.     {
  57.         return _q_value != value;
  58.     }
  59.     inline bool operator!() const
  60.     {
  61.         return _q_value == 0;
  62.     }
  63.     inline operator int() const
  64.     {
  65.         return _q_value;
  66.     }
  67.     inline QBasicAtomicInt &operator=(int value)
  68.     {
  69. #ifdef QT_ARCH_PARISC
  70.         this->_q_lock[0] = this->_q_lock[1] = this->_q_lock[2] = this->_q_lock[3] = -1;
  71. #endif
  72.         _q_value = value;
  73.         return *this;
  74.     }
  75.     // Atomic API, implemented in qatomic_XXX.h
  76.     static bool isReferenceCountingNative();
  77.     static bool isReferenceCountingWaitFree();
  78.     bool ref();
  79.     bool deref();
  80.     static bool isTestAndSetNative();
  81.     static bool isTestAndSetWaitFree();
  82.     bool testAndSetRelaxed(int expectedValue, int newValue);
  83.     bool testAndSetAcquire(int expectedValue, int newValue);
  84.     bool testAndSetRelease(int expectedValue, int newValue);
  85.     bool testAndSetOrdered(int expectedValue, int newValue);
  86.     static bool isFetchAndStoreNative();
  87.     static bool isFetchAndStoreWaitFree();
  88.     int fetchAndStoreRelaxed(int newValue);
  89.     int fetchAndStoreAcquire(int newValue);
  90.     int fetchAndStoreRelease(int newValue);
  91.     int fetchAndStoreOrdered(int newValue);
  92.     static bool isFetchAndAddNative();
  93.     static bool isFetchAndAddWaitFree();
  94.     int fetchAndAddRelaxed(int valueToAdd);
  95.     int fetchAndAddAcquire(int valueToAdd);
  96.     int fetchAndAddRelease(int valueToAdd);
  97.     int fetchAndAddOrdered(int valueToAdd);
  98. };
  99. template <typename T>
  100. class QBasicAtomicPointer
  101. {
  102. public:
  103. #ifdef QT_ARCH_PARISC
  104.     int _q_lock[4];
  105. #endif
  106.     T * volatile _q_value;
  107.     // Non-atomic API
  108.     inline bool operator==(T *value) const
  109.     {
  110.         return _q_value == value;
  111.     }
  112.     inline bool operator!=(T *value) const
  113.     {
  114.         return !operator==(value);
  115.     }
  116.     inline bool operator!() const
  117.     {
  118.         return operator==(0);
  119.     }
  120.     inline operator T *() const
  121.     {
  122.         return _q_value;
  123.     }
  124.     inline T *operator->() const
  125.     {
  126.         return _q_value;
  127.     }
  128.     inline QBasicAtomicPointer<T> &operator=(T *value)
  129.     {
  130. #ifdef QT_ARCH_PARISC
  131.         this->_q_lock[0] = this->_q_lock[1] = this->_q_lock[2] = this->_q_lock[3] = -1;
  132. #endif
  133.         _q_value = value;
  134.         return *this;
  135.     }
  136.     // Atomic API, implemented in qatomic_XXX.h
  137.     static bool isTestAndSetNative();
  138.     static bool isTestAndSetWaitFree();
  139.     bool testAndSetRelaxed(T *expectedValue, T *newValue);
  140.     bool testAndSetAcquire(T *expectedValue, T *newValue);
  141.     bool testAndSetRelease(T *expectedValue, T *newValue);
  142.     bool testAndSetOrdered(T *expectedValue, T *newValue);
  143.     static bool isFetchAndStoreNative();
  144.     static bool isFetchAndStoreWaitFree();
  145.     T *fetchAndStoreRelaxed(T *newValue);
  146.     T *fetchAndStoreAcquire(T *newValue);
  147.     T *fetchAndStoreRelease(T *newValue);
  148.     T *fetchAndStoreOrdered(T *newValue);
  149.     static bool isFetchAndAddNative();
  150.     static bool isFetchAndAddWaitFree();
  151.     T *fetchAndAddRelaxed(qptrdiff valueToAdd);
  152.     T *fetchAndAddAcquire(qptrdiff valueToAdd);
  153.     T *fetchAndAddRelease(qptrdiff valueToAdd);
  154.     T *fetchAndAddOrdered(qptrdiff valueToAdd);
  155. };
  156. #ifdef QT_ARCH_PARISC
  157. #  define Q_BASIC_ATOMIC_INITIALIZER(a) {{-1,-1,-1,-1},(a)}
  158. #else
  159. #  define Q_BASIC_ATOMIC_INITIALIZER(a) { (a) }
  160. #endif
  161. QT_END_NAMESPACE
  162. QT_END_HEADER
  163. #if defined(QT_MOC) || defined(QT_BUILD_QMAKE) || defined(QT_RCC) || defined(QT_UIC) || defined(QT_BOOTSTRAPPED)
  164. #  include <QtCore/qatomic_bootstrap.h>
  165. #else
  166. #  include <QtCore/qatomic_arch.h>
  167. #endif
  168. #endif // QBASIC_ATOMIC