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

系统编程

开发平台:

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 QFUTURE_H
  38. #define QFUTURE_H
  39. #include <QtCore/qglobal.h>
  40. #ifndef QT_NO_QFUTURE
  41. #include <QtCore/qfutureinterface.h>
  42. #include <QtCore/qstring.h>
  43. #include <QtCore/qtconcurrentcompilertest.h>
  44. QT_BEGIN_HEADER
  45. QT_BEGIN_NAMESPACE
  46. QT_MODULE(Core)
  47. template <typename T>
  48. class QFutureWatcher;
  49. template <>
  50. class QFutureWatcher<void>;
  51. template <typename T>
  52. class QFuture
  53. {
  54. public:
  55.     QFuture()
  56.         : d(QFutureInterface<T>::canceledResult())
  57.     { }
  58.     explicit QFuture(QFutureInterface<T> *p) // internal
  59.         : d(*p)
  60.     { }
  61.     QFuture(const QFuture &other)
  62.         : d(other.d)
  63.     { }
  64.     ~QFuture()
  65.     { }
  66.     inline QFuture &operator=(const QFuture &other);
  67.     bool operator==(const QFuture &other) const { return (d == other.d); }
  68.     bool operator!=(const QFuture &other) const { return (d != other.d); }
  69.     void cancel() { d.cancel(); }
  70.     bool isCanceled() const { return d.isCanceled(); }
  71.     void setPaused(bool paused) { d.setPaused(paused); }
  72.     bool isPaused() const { return d.isPaused(); }
  73.     void pause() { setPaused(true); }
  74.     void resume() { setPaused(false); }
  75.     void togglePaused() { d.togglePaused(); }
  76.     bool isStarted() const { return d.isStarted(); }
  77.     bool isFinished() const { return d.isFinished(); }
  78.     bool isRunning() const { return d.isRunning(); }
  79.     int resultCount() const { return d.resultCount(); }
  80.     int progressValue() const { return d.progressValue(); }
  81.     int progressMinimum() const { return d.progressMinimum(); }
  82.     int progressMaximum() const { return d.progressMaximum(); }
  83.     QString progressText() const { return d.progressText(); }
  84.     void waitForFinished() { d.waitForFinished(); }
  85.     inline T result() const;
  86.     inline T resultAt(int index) const;
  87.     bool isResultReadyAt(int index) const { return d.isResultReadyAt(index); }
  88.     operator T() const { return result(); }
  89.     QList<T> results() const { return d.results(); }
  90.     class const_iterator
  91.     {
  92.     public:
  93.         typedef std::bidirectional_iterator_tag iterator_category;
  94.         typedef ptrdiff_t difference_type;
  95.         typedef T value_type;
  96.         typedef const T *pointer;
  97.         typedef const T &reference;
  98.         inline const_iterator() {}
  99.         inline const_iterator(QFuture const * const _future, int _index) : future(_future), index(_index) {}
  100.         inline const_iterator(const const_iterator &o) : future(o.future), index(o.index)  {}
  101.         inline const_iterator &operator=(const const_iterator &o)
  102.         { future = o.future; index = o.index; return *this; }
  103.         inline const T &operator*() const { return future->d.resultReference(index); }
  104.         inline const T *operator->() const { return future->d.resultPointer(index); }
  105.         inline bool operator!=(const const_iterator &other) const
  106.         {
  107.             if (index == -1 && other.index == -1) // comparing end != end?
  108.                 return false;
  109.             if (other.index == -1)
  110.                 return (future->isRunning() || (index < future->resultCount()));
  111.             return (index != other.index);
  112.         }
  113.         inline bool operator==(const const_iterator &o) const { return !operator!=(o); }
  114.         inline const_iterator &operator++() { ++index; return *this; }
  115.         inline const_iterator operator++(int) { const_iterator r = *this; ++index; return r; }
  116.         inline const_iterator &operator--() { --index; return *this; }
  117.         inline const_iterator operator--(int) { const_iterator r = *this; --index; return r; }
  118.         inline const_iterator operator+(int j) const { return const_iterator(future, index + j); }
  119.         inline const_iterator operator-(int j) const { return const_iterator(future, index - j); }
  120.         inline const_iterator &operator+=(int j) { index += j; return *this; }
  121.         inline const_iterator &operator-=(int j) { index -= j; return *this; }
  122.     private:
  123.         QFuture const * future;
  124.         int index;
  125.     };
  126.     friend class const_iterator;
  127.     typedef const_iterator ConstIterator;
  128.     const_iterator begin() const { return  const_iterator(this, 0); }
  129.     const_iterator constBegin() const { return  const_iterator(this, 0); }
  130.     const_iterator end() const { return const_iterator(this, -1); }
  131.     const_iterator constEnd() const { return const_iterator(this, -1); }
  132. private:
  133.     friend class QFutureWatcher<T>;
  134. public: // Warning: the d pointer is not documented and is considered private.
  135.     mutable QFutureInterface<T> d;
  136. };
  137. template <typename T>
  138. inline QFuture<T> &QFuture<T>::operator=(const QFuture<T> &other)
  139. {
  140.     d = other.d;
  141.     return *this;
  142. }
  143. template <typename T>
  144. inline T QFuture<T>::result() const
  145. {
  146.     d.waitForResult(0);
  147.     return d.resultReference(0);
  148. }
  149. template <typename T>
  150. inline T QFuture<T>::resultAt(int index) const
  151. {
  152.     d.waitForResult(index);
  153.     return d.resultReference(index);
  154. }
  155. template <typename T>
  156. inline QFuture<T> QFutureInterface<T>::future()
  157. {
  158.     return QFuture<T>(this);
  159. }
  160. Q_DECLARE_SEQUENTIAL_ITERATOR(Future)
  161. template <>
  162. class QFuture<void>
  163. {
  164. public:
  165.     QFuture()
  166.         : d(QFutureInterface<void>::canceledResult())
  167.     { }
  168.     explicit QFuture(QFutureInterfaceBase *p) // internal
  169.         : d(*p)
  170.     { }
  171.     QFuture(const QFuture &other)
  172.         : d(other.d)
  173.     { }
  174.     ~QFuture()
  175.     { }
  176.     QFuture &operator=(const QFuture &other);
  177.     bool operator==(const QFuture &other) const { return (d == other.d); }
  178.     bool operator!=(const QFuture &other) const { return (d != other.d); }
  179. #ifndef QT_NO_MEMBER_TEMPLATES
  180.     template <typename T>
  181.     QFuture(const QFuture<T> &other)
  182.         : d(other.d)
  183.     { }
  184.     template <typename T>
  185.     QFuture<void> &operator=(const QFuture<T> &other)
  186.     {
  187.         d = other.d;
  188.         return *this;
  189.     }
  190. #endif
  191.     void cancel() { d.cancel(); }
  192.     bool isCanceled() const { return d.isCanceled(); }
  193.     void setPaused(bool paused) { d.setPaused(paused); }
  194.     bool isPaused() const { return d.isPaused(); }
  195.     void pause() { setPaused(true); }
  196.     void resume() { setPaused(false); }
  197.     void togglePaused() { d.togglePaused(); }
  198.     bool isStarted() const { return d.isStarted(); }
  199.     bool isFinished() const { return d.isFinished(); }
  200.     bool isRunning() const { return d.isRunning(); }
  201.     int resultCount() const { return d.resultCount(); }
  202.     int progressValue() const { return d.progressValue(); }
  203.     int progressMinimum() const { return d.progressMinimum(); }
  204.     int progressMaximum() const { return d.progressMaximum(); }
  205.     QString progressText() const { return d.progressText(); }
  206.     void waitForFinished() { d.waitForFinished(); }
  207. private:
  208.     friend class QFutureWatcher<void>;
  209. #ifdef QFUTURE_TEST
  210. public:
  211. #endif
  212.     mutable QFutureInterfaceBase d;
  213. };
  214. inline QFuture<void> &QFuture<void>::operator=(const QFuture<void> &other)
  215. {
  216.     d = other.d;
  217.     return *this;
  218. }
  219. inline QFuture<void> QFutureInterface<void>::future()
  220. {
  221.     return QFuture<void>(this);
  222. }
  223. template <typename T>
  224. QFuture<void> qToVoidFuture(const QFuture<T> &future)
  225. {
  226.     return QFuture<void>(future.d);
  227. }
  228. QT_END_NAMESPACE
  229. QT_END_HEADER
  230. #endif // QT_NO_CONCURRENT
  231. #endif // QFUTURE_H