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

系统编程

开发平台:

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 QATOMIC_H
  38. #define QATOMIC_H
  39. #include <QtCore/qglobal.h>
  40. #include <QtCore/qbasicatomic.h>
  41. QT_BEGIN_HEADER
  42. QT_BEGIN_NAMESPACE
  43. QT_MODULE(Core)
  44. // High-level atomic integer operations
  45. class Q_CORE_EXPORT QAtomicInt : public QBasicAtomicInt
  46. {
  47. public:
  48.     inline QAtomicInt(int value = 0)
  49.     {
  50. #ifdef QT_ARCH_PARISC
  51.         this->_q_lock[0] = this->_q_lock[1] = this->_q_lock[2] = this->_q_lock[3] = -1;
  52. #endif
  53.         _q_value = value;
  54.     }
  55.     inline QAtomicInt(const QAtomicInt &other)
  56.     {
  57. #ifdef QT_ARCH_PARISC
  58.         this->_q_lock[0] = this->_q_lock[1] = this->_q_lock[2] = this->_q_lock[3] = -1;
  59. #endif
  60.         _q_value = other._q_value;
  61.     }
  62.     inline QAtomicInt &operator=(int value)
  63.     {
  64.         (void) QBasicAtomicInt::operator=(value);
  65.         return *this;
  66.     }
  67.     inline QAtomicInt &operator=(const QAtomicInt &other)
  68.     {
  69.         (void) QBasicAtomicInt::operator=(other);
  70.         return *this;
  71.     }
  72. #ifdef qdoc
  73.     bool operator==(int value) const;
  74.     bool operator!=(int value) const;
  75.     bool operator!() const;
  76.     operator int() const;
  77.     static bool isReferenceCountingNative();
  78.     static bool isReferenceCountingWaitFree();
  79.     bool ref();
  80.     bool deref();
  81.     static bool isTestAndSetNative();
  82.     static bool isTestAndSetWaitFree();
  83.     bool testAndSetRelaxed(int expectedValue, int newValue);
  84.     bool testAndSetAcquire(int expectedValue, int newValue);
  85.     bool testAndSetRelease(int expectedValue, int newValue);
  86.     bool testAndSetOrdered(int expectedValue, int newValue);
  87.     static bool isFetchAndStoreNative();
  88.     static bool isFetchAndStoreWaitFree();
  89.     int fetchAndStoreRelaxed(int newValue);
  90.     int fetchAndStoreAcquire(int newValue);
  91.     int fetchAndStoreRelease(int newValue);
  92.     int fetchAndStoreOrdered(int newValue);
  93.     static bool isFetchAndAddNative();
  94.     static bool isFetchAndAddWaitFree();
  95.     int fetchAndAddRelaxed(int valueToAdd);
  96.     int fetchAndAddAcquire(int valueToAdd);
  97.     int fetchAndAddRelease(int valueToAdd);
  98.     int fetchAndAddOrdered(int valueToAdd);
  99. #endif
  100. };
  101. // High-level atomic pointer operations
  102. template <typename T>
  103. class QAtomicPointer : public QBasicAtomicPointer<T>
  104. {
  105. public:
  106.     inline QAtomicPointer(T *value = 0)
  107.     {
  108. #ifdef QT_ARCH_PARISC
  109.         this->_q_lock[0] = this->_q_lock[1] = this->_q_lock[2] = this->_q_lock[3] = -1;
  110. #endif
  111.         QBasicAtomicPointer<T>::_q_value = value;
  112.     }
  113.     inline QAtomicPointer(const QAtomicPointer<T> &other)
  114.     {
  115. #ifdef QT_ARCH_PARISC
  116.         this->_q_lock[0] = this->_q_lock[1] = this->_q_lock[2] = this->_q_lock[3] = -1;
  117. #endif
  118.         QBasicAtomicPointer<T>::_q_value = other._q_value;
  119.     }
  120.     inline QAtomicPointer<T> &operator=(T *value)
  121.     {
  122.         (void) QBasicAtomicPointer<T>::operator=(value);
  123.         return *this;
  124.     }
  125.     inline QAtomicPointer<T> &operator=(const QAtomicPointer<T> &other)
  126.     {
  127.         (void) QBasicAtomicPointer<T>::operator=(other);
  128.         return *this;
  129.     }
  130. #ifdef qdoc
  131.     bool operator==(T *value) const;
  132.     bool operator!=(T *value) const;
  133.     bool operator!() const;
  134.     operator T *() const;
  135.     T *operator->() const;
  136.     static bool isTestAndSetNative();
  137.     static bool isTestAndSetWaitFree();
  138.     bool testAndSetRelaxed(T *expectedValue, T *newValue);
  139.     bool testAndSetAcquire(T *expectedValue, T *newValue);
  140.     bool testAndSetRelease(T *expectedValue, T *newValue);
  141.     bool testAndSetOrdered(T *expectedValue, T *newValue);
  142.     static bool isFetchAndStoreNative();
  143.     static bool isFetchAndStoreWaitFree();
  144.     T *fetchAndStoreRelaxed(T *newValue);
  145.     T *fetchAndStoreAcquire(T *newValue);
  146.     T *fetchAndStoreRelease(T *newValue);
  147.     T *fetchAndStoreOrdered(T *newValue);
  148.     static bool isFetchAndAddNative();
  149.     static bool isFetchAndAddWaitFree();
  150.     T *fetchAndAddRelaxed(qptrdiff valueToAdd);
  151.     T *fetchAndAddAcquire(qptrdiff valueToAdd);
  152.     T *fetchAndAddRelease(qptrdiff valueToAdd);
  153.     T *fetchAndAddOrdered(qptrdiff valueToAdd);
  154. #endif
  155. };
  156. /*!
  157.     This is a helper for the assignment operators of implicitly
  158.     shared classes. Your assignment operator should look like this:
  159.     snippet doc/src/snippets/code/src.corelib.thread.qatomic.h 0
  160. */
  161. template <typename T>
  162. inline void qAtomicAssign(T *&d, T *x)
  163. {
  164.     if (d == x)
  165.         return;
  166.     x->ref.ref();
  167.     if (!d->ref.deref())
  168.         delete d;
  169.     d = x;
  170. }
  171. /*!
  172.     This is a helper for the detach method of implicitly shared
  173.     classes. Your private class needs a copy constructor which copies
  174.     the members and sets the refcount to 1. After that, your detach
  175.     function should look like this:
  176.     snippet doc/src/snippets/code/src.corelib.thread.qatomic.h 1
  177. */
  178. template <typename T>
  179. inline void qAtomicDetach(T *&d)
  180. {
  181.     if (d->ref == 1)
  182.         return;
  183.     T *x = d;
  184.     d = new T(*d);
  185.     if (!x->ref.deref())
  186.         delete x;
  187. }
  188. QT_END_NAMESPACE
  189. QT_END_HEADER
  190. #endif // QATOMIC_H