src/concurrent/qfuturewatcher.h

   1 /****************************************************************************
   2 **
   3 ** Copyright (C) 2012 Nokia Corporation and/or its subsidiary(-ies).
   4 ** Contact: http://www.qt-project.org/
   5 **
   6 ** This file is part of the QtCore module of the Qt Toolkit.
   7 **
   8 ** $QT_BEGIN_LICENSE:LGPL$
   9 ** GNU Lesser General Public License Usage
  10 ** This file may be used under the terms of the GNU Lesser General Public
  11 ** License version 2.1 as published by the Free Software Foundation and
  12 ** appearing in the file LICENSE.LGPL included in the packaging of this
  13 ** file. Please review the following information to ensure the GNU Lesser
  14 ** General Public License version 2.1 requirements will be met:
  15 ** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
  16 **
  17 ** In addition, as a special exception, Nokia gives you certain additional
  18 ** rights. These rights are described in the Nokia Qt LGPL Exception
  19 ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
  20 **
  21 ** GNU General Public License Usage
  22 ** Alternatively, this file may be used under the terms of the GNU General
  23 ** Public License version 3.0 as published by the Free Software Foundation
  24 ** and appearing in the file LICENSE.GPL included in the packaging of this
  25 ** file. Please review the following information to ensure the GNU General
  26 ** Public License version 3.0 requirements will be met:
  27 ** http://www.gnu.org/copyleft/gpl.html.
  28 **
  29 ** Other Usage
  30 ** Alternatively, this file may be used in accordance with the terms and
  31 ** conditions contained in a signed written agreement between you and Nokia.
  32 **
  33 **
  34 **
  35 **
  36 **
  37 **
  38 ** $QT_END_LICENSE$
  39 **
  40 ****************************************************************************/
  41
  42 #ifndef QFUTUREWATCHER_H
  43 #define QFUTUREWATCHER_H
  44
  45 #include <QtConcurrent/qtconcurrent_global.h>
  46
  47 #include <QtConcurrent/qfuture.h>
  48
  49 #ifndef QT_NO_QFUTURE
  50
  51 #include <QtCore/qobject.h>
  52
  53 QT_BEGIN_HEADER
  54 QT_BEGIN_NAMESPACE
  55
  56
  57 class QEvent;
  58
  59 class QFutureWatcherBasePrivate;
  60 class Q_CONCURRENT_EXPORT QFutureWatcherBase : public QObject
  61 {
  62     Q_OBJECT
  63     Q_DECLARE_PRIVATE(QFutureWatcherBase)
  64
  65 public:
  66     QFutureWatcherBase(QObject *parent = 0);
  67
  68     int progressValue() const;
  69     int progressMinimum() const;
  70     int progressMaximum() const;
  71     QString progressText() const;
  72
  73     bool isStarted() const;
  74     bool isFinished() const;
  75     bool isRunning() const;
  76     bool isCanceled() const;
  77     bool isPaused() const;
  78
  79     void waitForFinished();
  80
  81     void setPendingResultsLimit(int limit);
  82
  83     bool event(QEvent *event);
  84
  85 Q_SIGNALS:
  86     void started();
  87     void finished();
  88     void canceled();
  89     void paused();
  90     void resumed();
  91     void resultReadyAt(int resultIndex);
  92     void resultsReadyAt(int beginIndex, int endIndex);
  93     void progressRangeChanged(int minimum, int maximum);
  94     void progressValueChanged(int progressValue);
  95     void progressTextChanged(const QString &progressText);
  96
  97 public Q_SLOTS:
  98     void cancel();
  99     void setPaused(bool paused);
 100     void pause();
 101     void resume();
 102     void togglePaused();
 103
 104 protected:
 105     void connectNotify (const char * signal);
 106     void disconnectNotify (const char * signal);
 107
 108     // called from setFuture() implemented in template sub-classes
 109     void connectOutputInterface();
 110     void disconnectOutputInterface(bool pendingAssignment = false);
 111
 112 private:
 113     // implemented in the template sub-classes
 114     virtual const QFutureInterfaceBase &futureInterface() const = 0;
 115     virtual QFutureInterfaceBase &futureInterface() = 0;
 116 };
 117
 118 template <typename T>
 119 class QFutureWatcher : public QFutureWatcherBase
 120 {
 121 public:
 122     QFutureWatcher(QObject *_parent = 0)
 123         : QFutureWatcherBase(_parent)
 124     { }
 125     ~QFutureWatcher()
 126     { disconnectOutputInterface(); }
 127
 128     void setFuture(const QFuture<T> &future);
 129     QFuture<T> future() const
 130     { return m_future; }
 131
 132     T result() const { return m_future.result(); }
 133     T resultAt(int index) const { return m_future.resultAt(index); }
 134
 135 #ifdef qdoc
 136     int progressValue() const;
 137     int progressMinimum() const;
 138     int progressMaximum() const;
 139     QString progressText() const;
 140
 141     bool isStarted() const;
 142     bool isFinished() const;
 143     bool isRunning() const;
 144     bool isCanceled() const;
 145     bool isPaused() const;
 146
 147     void waitForFinished();
 148
 149     void setPendingResultsLimit(int limit);
 150
 151 Q_SIGNALS:
 152     void started();
 153     void finished();
 154     void canceled();
 155     void paused();
 156     void resumed();
 157     void resultReadyAt(int resultIndex);
 158     void resultsReadyAt(int beginIndex, int endIndex);
 159     void progressRangeChanged(int minimum, int maximum);
 160     void progressValueChanged(int progressValue);
 161     void progressTextChanged(const QString &progressText);
 162
 163 public Q_SLOTS:
 164     void cancel();
 165     void setPaused(bool paused);
 166     void pause();
 167     void resume();
 168     void togglePaused();
 169 #endif
 170
 171 private:
 172     QFuture<T> m_future;
 173     const QFutureInterfaceBase &futureInterface() const { return m_future.d; }
 174     QFutureInterfaceBase &futureInterface() { return m_future.d; }
 175 };
 176
 177 template <typename T>
 178 Q_INLINE_TEMPLATE void QFutureWatcher<T>::setFuture(const QFuture<T> &_future)
 179 {
 180     if (_future == m_future)
 181         return;
 182
 183     disconnectOutputInterface(true);
 184     m_future = _future;
 185     connectOutputInterface();
 186 }
 187
 188 template <>
 189 class QFutureWatcher<void> : public QFutureWatcherBase
 190 {
 191 public:
 192     QFutureWatcher(QObject *_parent = 0)
 193         : QFutureWatcherBase(_parent)
 194     { }
 195     ~QFutureWatcher()
 196     { disconnectOutputInterface(); }
 197
 198     void setFuture(const QFuture<void> &future);
 199     QFuture<void> future() const
 200     { return m_future; }
 201
 202 private:
 203     QFuture<void> m_future;
 204     const QFutureInterfaceBase &futureInterface() const { return m_future.d; }
 205     QFutureInterfaceBase &futureInterface() { return m_future.d; }
 206 };
 207
 208 Q_INLINE_TEMPLATE void QFutureWatcher<void>::setFuture(const QFuture<void> &_future)
 209 {
 210     if (_future == m_future)
 211         return;
 212
 213     disconnectOutputInterface(true);
 214     m_future = _future;
 215     connectOutputInterface();
 216 }
 217
 218 QT_END_NAMESPACE
 219 QT_END_HEADER
 220
 221 #endif // QT_NO_CONCURRENT
 222
 223 #endif // QFUTUREWATCHER_H