Класс QFutureWatcher

Класс QFutureWatcher позволяет отслеживать QFuture с помощью сигналов и слотов. Подробнее...

• Список всех членов, включая унаследованные

Примечание: Все функции в этом классе являются перевходящими.

Открытые функции

• 32 открытых функций, унаследованных от QObject

Открытые слоты

• 1 открытый слот, унаследованный от QObject

Сигналы

• 2 сигнала, унаследованные от QObject

Дополнительные унаследованные члены

• 1 свойство, унаследованное от QObject
• 11 статических открытых членов, унаследованных от QObject
• 9 защищенных функций, унаследованных от QObject

Подробное описание

Класс QFutureWatcher позволяет отслеживать QFuture с помощью сигналов и слотов.

QFutureWatcher предоставляет информацию и уведомления о QFuture. Используйте функцию setFuture() для начала отслеживания конкретной QFuture. Функция future() возвращает установленное с помощью setFuture() future.

Для удобства несколько функций QFuture также доступны в QFutureWatcher: progressValue(), progressMinimum(), progressMaximum(), progressText(), isStarted(), isFinished(), isRunning(), isCanceled(), isPaused(), waitForFinished(), result() и resultAt(). Функции cancel(), setPaused(), pause(), resume() и togglePaused() являются слотами в QFutureWatcher.

Изменения статуса сообщаются через сигналы started(), finished(), canceled(), paused(), resumed(), resultReadyAt() и resultsReadyAt(). Информация о ходе выполнения предоставляется сигналами progressRangeChanged(), void progressValueChanged() и progressTextChanged().

Управление ограничением предоставляется функцией setPendingResultsLimit(). Когда количество ожидающих сигналов resultReadyAt() или resultsReadyAt() превышает лимит, вычисления, представленные future, будут автоматически ограничены. Вычисления будут возобновлены, как только количество ожидающих сигналов упадет ниже лимита.

Пример: запуск вычисления и получение обратного вызова слота при завершении:

// Instantiate the objects and connect to the finished signal.
MyClass myObject;
QFutureWatcher<int> watcher;
connect(&watcher, SIGNAL(finished()), &myObject, SLOT(handleFinished()));

// Start the computation.
QFuture<int> future = QtConcurrent::run(...);
watcher.setFuture(future);

Обратите внимание, что не все асинхронные вычисления могут быть отменены или приостановлены. Например, future, возвращаемый функцией QtConcurrent::run(), не может быть отменен; но future, возвращаемый функцией QtConcurrent::mappedReduced(), может.

QFutureWatcher<void> специализируется на том, чтобы не содержать ни одной из функций получения результатов. Любое QFuture<T> может быть отслежено QFutureWatcher<void>, а также. Это полезно, если нужна только информация о состоянии или ходе выполнения, а не фактические данные результата.

См. также QFuture и Qt Concurrent.

Документация по функциям-членам

QFutureWatcher::QFutureWatcher(QObject *parent = nullptr)

Конструирует новый QFutureWatcher с указанным parent.

[virtual] QFutureWatcher::~QFutureWatcher()

Уничтожает наблюдаемый QFutureWatcher.

[slot] void QFutureWatcher::cancel()

Отменяет асинхронное вычисление, представленное задачей(). Обратите внимание, что отмена асинхронна. Используйте waitForFinished() после вызова cancel(), если требуется синхронная отмена.

Текущие доступные результаты все еще могут быть получены из отмененной QFuture, но новые результаты не будут доступны после вызова этой функции. Кроме того, этот QFutureWatcher не будет передавать сигналы о ходе и готовности результата после отмены. Это включает сигналы progressValueChanged(), progressRangeChanged(), progressTextChanged(), resultReadyAt() и resultsReadyAt().

Учитывайте, что не все асинхронные вычисления могут быть отменены. Например, QFuture, возвращаемая QtConcurrent::run(), не может быть отменена; но QFuture, возвращаемая QtConcurrent::mappedReduced(), может.

[signal] void QFutureWatcher::canceled()

Этот сигнал испускается, если наблюдаемая задача отменена.

[signal] void QFutureWatcher::finished()

Этот сигнал испускается, когда наблюдаемая задача завершается.

QFuture<T> QFutureWatcher::future() const

Возвращает наблюдаемую задачу.

См. также setFuture().

bool QFutureWatcher::isCanceled() const

Возвращает true если асинхронное вычисление было отменено с помощью функции cancel(); в противном случае возвращает false.

Учитывайте, что вычисление может всё еще выполняться, даже если эта функция возвращает true. См. cancel() для более подробной информации.

bool QFutureWatcher::isFinished() const

Возвращает true если асинхронное вычисление, представленное задачей(), завершилось или если задача не задана; в противном случае возвращает false.

bool QFutureWatcher::isPaused() const

Возвращает true если асинхронное вычисление было приостановлено с помощью функции pause(); в противном случае возвращает false.

Учитывайте, что вычисление может всё еще выполняться, даже если эта функция возвращает true. См. setPaused() для более подробной информации.

См. также setPaused() и togglePaused().

bool QFutureWatcher::isRunning() const

Возвращает true если асинхронное вычисление, представленное задачей(), в настоящее время выполняется; в противном случае возвращает false.

bool QFutureWatcher::isStarted() const

Возвращает true если асинхронное вычисление, представленное задачей(), было запущено; в противном случае возвращает false.

[slot] void QFutureWatcher::pause()

Приостанавливает асинхронное вычисление, представленное задачей(). Это удобный метод, который просто вызывает setPaused(true).

См. также resume().

[signal] void QFutureWatcher::paused()

Этот сигнал испускается, когда наблюдаемая задача приостанавливается.

См. также setPaused().

int QFutureWatcher::progressMaximum() const

Возвращает максимальное значение прогресса progressValue().

См. также progressValue() и progressMinimum().

int QFutureWatcher::progressMinimum() const

Возвращает минимальное значение прогресса progressValue().

См. также progressValue() и progressMaximum().

[signal] void QFutureWatcher::progressRangeChanged(int minimum, int maximum)

Диапазон прогресса наблюдаемой задачи изменился на minimum и maximum.

QString QFutureWatcher::progressText() const

Возвращает (необязательное) текстовое представление прогресса, как сообщается асинхронным вычислением.

Обратите внимание, что не все вычисления предоставляют текстовое представление прогресса, и поэтому эта функция может вернуть пустую строку.

[signal] void QFutureWatcher::progressTextChanged(const QString &progressText)

Этот сигнал испускается, когда наблюдаемая задача сообщает текстовую информацию о прогрессе, progressText.

int QFutureWatcher::progressValue() const

Возвращает текущее значение прогресса, которое находится между progressMinimum() и progressMaximum().

См. также progressMinimum() и progressMaximum().

[signal] void QFutureWatcher::progressValueChanged(int progressValue)

Этот сигнал испускается, когда наблюдаемая задача сообщает о прогрессе, progressValue указывает текущий прогресс. Для предотвращения перегрузки цикла событий графического интерфейса QFutureWatcher ограничивает скорость испускания сигналов о прогрессе. Это означает, что подписчики, подключенные к этому слоту, могут не получить все сообщения о прогрессе, отправленные задачей. Последнее обновление прогресса (где progressValue равно максимальному значению) всегда будет доставлено.

T QFutureWatcher::result() const

Возвращает первый результат в задаче(). Если результат немедленно недоступен, эта функция заблокируется и будет ожидать, пока результат не станет доступным. Это удобный метод для вызова resultAt(0).

См. также resultAt().

T QFutureWatcher::resultAt(int index) const

Возвращает результат по индексу index в задаче(). Если результат немедленно недоступен, эта функция заблокируется и будет ожидать, пока результат не станет доступным.

См. также result().

[signal] void QFutureWatcher::resultReadyAt(int index)

Этот сигнал испускается, когда наблюдаемая задача сообщает о готовом результате по индексу index. Если задача сообщает о нескольких результатах, индекс указывает, какой именно результат. Результаты могут быть сообщены вне порядка. Чтобы получить результат, вызовите resultAt(index);

[signal] void QFutureWatcher::resultsReadyAt(int beginIndex, int endIndex)

Этот сигнал испускается, когда наблюдаемая задача сообщает о готовых результатах. Результаты индексируются с beginIndex по endIndex.

[slot] void QFutureWatcher::resume()

Возобновляет асинхронное вычисление, представленное задачей(). Это удобный метод, который просто вызывает setPaused(false).

См. также pause().

[signal] void QFutureWatcher::resumed()

Этот сигнал испускается, когда наблюдаемая задача возобновляется.

void QFutureWatcher::setFuture(const QFuture<T> &future)

Начинает наблюдение за заданной задачей.

Один из сигналов может быть испущен для текущего состояния задачи. Например, если задача уже остановлена, будет испущен сигнал finished.

Чтобы избежать гонки, важно вызвать эту функцию после выполнения соединений.

См. также future().

[slot] void QFutureWatcher::setPaused(bool paused)

Если paused равно true, эта функция приостанавливает асинхронное вычисление, представленное задачей(). Если вычисление уже приостановлено, эта функция ничего не делает. Этот QFutureWatcher прекратит передавать сигналы прогресса и готовности результата, пока задача приостановлена. Передача сигналов продолжится после возобновления вычисления.

Если paused имеет значение false, эта функция возобновляет асинхронное вычисление. Если вычисление ранее не было приостановлено, эта функция ничего не делает.

Обратите внимание, что не все вычисления могут быть приостановлены. Например, QFuture, возвращаемый QtConcurrent::run(), не может быть приостановлен; но QFuture, возвращаемый QtConcurrent::mappedReduced(), может.

См. также paused(), pause(), resume() и togglePaused().

void QFutureWatcher::setPendingResultsLimit(int limit)

setPendingResultsLimit() предоставляет управление ограничением скорости. Когда количество ожидающих сигналов resultReadyAt() или resultsReadyAt() превышает limit, вычисление, представленное будущим, будет автоматически ограничено. Вычисление возобновится, когда количество ожидающих сигналов станет меньше limit.

[signal] void QFutureWatcher::started()

Этот сигнал излучается, когда этот QFutureWatcher начинает наблюдать за будущим, заданным с помощью setFuture().

[slot] void QFutureWatcher::togglePaused()

Переключает состояние приостановки асинхронного вычисления. Другими словами, если вычисление в настоящее время приостановлено, вызов этой функции возобновляет его; если вычисление выполняется, оно переходит в приостановленное состояние. Это удобный метод для вызова setPaused(!isPaused()).

См. также setPaused(), pause() и resume().

void QFutureWatcher::waitForFinished()

Ожидает завершения асинхронного вычисления (включая отменённые cancel() вычисления).