Класс QFutureWatcher

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

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

Примечание: Все функции в этом классе являются реентерабельными.

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

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

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

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

Сигналы

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

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

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

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

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

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

Для удобства некоторые функции 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(), progressValueChanged() и progressTextChanged().

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

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

// 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);

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

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

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

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

QFutureWatcher::QFutureWatcher(QObject *parent = nullptr)

Создаёт новый QFutureWatcher с заданным parent. До тех пор, пока будущее не будет установлено с помощью setFuture(), функции isStarted(), isCanceled() и isFinished() возвращают true.

[virtual] QFutureWatcher::~QFutureWatcher()

Удаляет QFutureWatcher.

[slot] void QFutureWatcher::cancel()

Отменяет асинхронное вычисление, представленное future(). Обратите внимание, что отмена является асинхронной. Используйте 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 если асинхронное вычисление, представленное future(), завершилось или если будущее не было установлено; в противном случае возвращает false.

bool QFutureWatcher::isPaused() const

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

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

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

bool QFutureWatcher::isRunning() const

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

bool QFutureWatcher::isStarted() const

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

[slot] void QFutureWatcher::pause()

Приостанавливает асинхронное вычисление, представленное future(). Это удобный метод, который просто вызывает 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 задаёт текущий прогресс. Для предотвращения перегрузки цикла событий GUI, QFutureWatcher ограничивает скорость излучения сигналов прогресса. Это означает, что слушатели, подключённые к этому слоту, могут не получить все сообщения о прогрессе, которые делает будущее. Последнее обновление прогресса (где progressValue равно максимальному значению) всегда будет доставлено.

T QFutureWatcher::result() const

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

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

T QFutureWatcher::resultAt(int index) const

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

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

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

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

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

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

[slot] void QFutureWatcher::resume()

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

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

[signal] void QFutureWatcher::resumed()

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

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

Начинает отслеживание заданного future.

Один из сигналов может быть излучен для текущего состояния 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() вычисления).