src/corelib/concurrent/qfuture.h

   1 /****************************************************************************
   2 **
   3 ** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
   4 ** All rights reserved.
   5 ** Contact: Nokia Corporation (qt-info@nokia.com)
   6 **
   7 ** This file is part of the QtCore module of the Qt Toolkit.
   8 **
   9 ** $QT_BEGIN_LICENSE:LGPL$
  10 ** No Commercial Usage
  11 ** This file contains pre-release code and may not be distributed.
  12 ** You may use this file in accordance with the terms and conditions
  13 ** contained in the Technology Preview License Agreement accompanying
  14 ** this package.
  15 **
  16 ** GNU Lesser General Public License Usage
  17 ** Alternatively, this file may be used under the terms of the GNU Lesser
  18 ** General Public License version 2.1 as published by the Free Software
  19 ** Foundation and appearing in the file LICENSE.LGPL included in the
  20 ** packaging of this file.  Please review the following information to
  21 ** ensure the GNU Lesser General Public License version 2.1 requirements
  22 ** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
  23 **
  24 ** In addition, as a special exception, Nokia gives you certain additional
  25 ** rights.  These rights are described in the Nokia Qt LGPL Exception
  26 ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
  27 **
  28 ** If you have questions regarding the use of this file, please contact
  29 ** Nokia at qt-info@nokia.com.
  30 **
  31 **
  32 **
  33 **
  34 **
  35 **
  36 **
  37 **
  38 ** $QT_END_LICENSE$
  39 **
  40 ****************************************************************************/
  41
  42 #ifndef QFUTURE_H
  43 #define QFUTURE_H
  44
  45 #include <QtCore/qglobal.h>
  46
  47 #ifndef QT_NO_QFUTURE
  48
  49 #include <QtCore/qfutureinterface.h>
  50 #include <QtCore/qstring.h>
  51 #include <QtCore/qtconcurrentcompilertest.h>
  52
  53 QT_BEGIN_HEADER
  54 QT_BEGIN_NAMESPACE
  55
  56 QT_MODULE(Core)
  57
  58 template <typename T>
  59 class QFutureWatcher;
  60 template <>
  61 class QFutureWatcher<void>;
  62
  63 template <typename T>
  64 class QFuture
  65 {
  66 public:
  67     QFuture()
  68         : d(QFutureInterface<T>::canceledResult())
  69     { }
  70     explicit QFuture(QFutureInterface<T> *p) // internal
  71         : d(*p)
  72     { }
  73     QFuture(const QFuture &other)
  74         : d(other.d)
  75     { }
  76     ~QFuture()
  77     { }
  78
  79     inline QFuture &operator=(const QFuture &other);
  80     bool operator==(const QFuture &other) const { return (d == other.d); }
  81     bool operator!=(const QFuture &other) const { return (d != other.d); }
  82
  83     void cancel() { d.cancel(); }
  84     bool isCanceled() const { return d.isCanceled(); }
  85
  86     void setPaused(bool paused) { d.setPaused(paused); }
  87     bool isPaused() const { return d.isPaused(); }
  88     void pause() { setPaused(true); }
  89     void resume() { setPaused(false); }
  90     void togglePaused() { d.togglePaused(); }
  91
  92     bool isStarted() const { return d.isStarted(); }
  93     bool isFinished() const { return d.isFinished(); }
  94     bool isRunning() const { return d.isRunning(); }
  95
  96     int resultCount() const { return d.resultCount(); }
  97     int progressValue() const { return d.progressValue(); }
  98     int progressMinimum() const { return d.progressMinimum(); }
  99     int progressMaximum() const { return d.progressMaximum(); }
 100     QString progressText() const { return d.progressText(); }
 101     void waitForFinished() { d.waitForFinished(); }
 102
 103     inline T result() const;
 104     inline T resultAt(int index) const;
 105     bool isResultReadyAt(int resultIndex) const { return d.isResultReadyAt(resultIndex); }
 106
 107     operator T() const { return result(); }
 108     QList<T> results() const { return d.results(); }
 109
 110     class const_iterator
 111     {
 112     public:
 113         typedef std::bidirectional_iterator_tag iterator_category;
 114         typedef ptrdiff_t difference_type;
 115         typedef T value_type;
 116         typedef const T *pointer;
 117         typedef const T &reference;
 118
 119         inline const_iterator() {}
 120         inline const_iterator(QFuture const * const _future, int _index) : future(_future), index(_index) {}
 121         inline const_iterator(const const_iterator &o) : future(o.future), index(o.index)  {}
 122         inline const_iterator &operator=(const const_iterator &o)
 123         { future = o.future; index = o.index; return *this; }
 124         inline const T &operator*() const { return future->d.resultReference(index); }
 125         inline const T *operator->() const { return future->d.resultPointer(index); }
 126
 127         inline bool operator!=(const const_iterator &other) const
 128         {
 129             if (index == -1 && other.index == -1) // comparing end != end?
 130                 return false;
 131             if (other.index == -1)
 132                 return (future->isRunning() || (index < future->resultCount()));
 133             return (index != other.index);
 134         }
 135
 136         inline bool operator==(const const_iterator &o) const { return !operator!=(o); }
 137         inline const_iterator &operator++() { ++index; return *this; }
 138         inline const_iterator operator++(int) { const_iterator r = *this; ++index; return r; }
 139         inline const_iterator &operator--() { --index; return *this; }
 140         inline const_iterator operator--(int) { const_iterator r = *this; --index; return r; }
 141         inline const_iterator operator+(int j) const { return const_iterator(future, index + j); }
 142         inline const_iterator operator-(int j) const { return const_iterator(future, index - j); }
 143         inline const_iterator &operator+=(int j) { index += j; return *this; }
 144         inline const_iterator &operator-=(int j) { index -= j; return *this; }
 145     private:
 146         QFuture const * future;
 147         int index;
 148     };
 149     friend class const_iterator;
 150     typedef const_iterator ConstIterator;
 151
 152     const_iterator begin() const { return  const_iterator(this, 0); }
 153     const_iterator constBegin() const { return  const_iterator(this, 0); }
 154     const_iterator end() const { return const_iterator(this, -1); }
 155     const_iterator constEnd() const { return const_iterator(this, -1); }
 156
 157 private:
 158     friend class QFutureWatcher<T>;
 159
 160 public: // Warning: the d pointer is not documented and is considered private.
 161     mutable QFutureInterface<T> d;
 162 };
 163
 164 template <typename T>
 165 inline QFuture<T> &QFuture<T>::operator=(const QFuture<T> &other)
 166 {
 167     d = other.d;
 168     return *this;
 169 }
 170
 171 template <typename T>
 172 inline T QFuture<T>::result() const
 173 {
 174     d.waitForResult(0);
 175     return d.resultReference(0);
 176 }
 177
 178 template <typename T>
 179 inline T QFuture<T>::resultAt(int index) const
 180 {
 181     d.waitForResult(index);
 182     return d.resultReference(index);
 183 }
 184
 185 template <typename T>
 186 inline QFuture<T> QFutureInterface<T>::future()
 187 {
 188     return QFuture<T>(this);
 189 }
 190
 191 Q_DECLARE_SEQUENTIAL_ITERATOR(Future)
 192
 193 template <>
 194 class QFuture<void>
 195 {
 196 public:
 197     QFuture()
 198         : d(QFutureInterface<void>::canceledResult())
 199     { }
 200     explicit QFuture(QFutureInterfaceBase *p) // internal
 201         : d(*p)
 202     { }
 203     QFuture(const QFuture &other)
 204         : d(other.d)
 205     { }
 206     ~QFuture()
 207     { }
 208
 209     QFuture &operator=(const QFuture &other);
 210     bool operator==(const QFuture &other) const { return (d == other.d); }
 211     bool operator!=(const QFuture &other) const { return (d != other.d); }
 212
 213 #if !defined(QT_NO_MEMBER_TEMPLATES) && !defined(Q_CC_XLC)
 214     template <typename T>
 215     QFuture(const QFuture<T> &other)
 216         : d(other.d)
 217     { }
 218
 219     template <typename T>
 220     QFuture<void> &operator=(const QFuture<T> &other)
 221     {
 222         d = other.d;
 223         return *this;
 224     }
 225 #endif
 226
 227     void cancel() { d.cancel(); }
 228     bool isCanceled() const { return d.isCanceled(); }
 229
 230     void setPaused(bool paused) { d.setPaused(paused); }
 231     bool isPaused() const { return d.isPaused(); }
 232     void pause() { setPaused(true); }
 233     void resume() { setPaused(false); }
 234     void togglePaused() { d.togglePaused(); }
 235
 236     bool isStarted() const { return d.isStarted(); }
 237     bool isFinished() const { return d.isFinished(); }
 238     bool isRunning() const { return d.isRunning(); }
 239
 240     int resultCount() const { return d.resultCount(); }
 241     int progressValue() const { return d.progressValue(); }
 242     int progressMinimum() const { return d.progressMinimum(); }
 243     int progressMaximum() const { return d.progressMaximum(); }
 244     QString progressText() const { return d.progressText(); }
 245     void waitForFinished() { d.waitForFinished(); }
 246
 247 private:
 248     friend class QFutureWatcher<void>;
 249
 250 #ifdef QFUTURE_TEST
 251 public:
 252 #endif
 253     mutable QFutureInterfaceBase d;
 254 };
 255
 256 inline QFuture<void> &QFuture<void>::operator=(const QFuture<void> &other)
 257 {
 258     d = other.d;
 259     return *this;
 260 }
 261
 262 inline QFuture<void> QFutureInterface<void>::future()
 263 {
 264     return QFuture<void>(this);
 265 }
 266
 267 template <typename T>
 268 QFuture<void> qToVoidFuture(const QFuture<T> &future)
 269 {
 270     return QFuture<void>(future.d);
 271 }
 272
 273 QT_END_NAMESPACE
 274 QT_END_HEADER
 275
 276 #endif // QT_NO_CONCURRENT
 277
 278 #endif // QFUTURE_H