Класс QFutureWatcher

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

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

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

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

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

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

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

Сигналы

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

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

• 1 свойство, унаследованное от QObject
• 11 статических открытых членов, унаследованных от QObject
• 2 защищенных функции, унаследованные от QFutureWatcherBase
• 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(), void 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.

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()

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

[signal] void QFutureWatcher::finished()

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

QFuture<T> QFutureWatcher::future() const

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

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

bool QFutureWatcher::isCanceled() const

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

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

bool QFutureWatcher::isFinished() const

Возвращает true если асинхронное вычисление, представленное future(), завершено или если 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()

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

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

int QFutureWatcher::progressMaximum() const

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

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

int QFutureWatcher::progressMinimum() const

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

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

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

Диапазон хода выполнения наблюдаемого future изменился на minimum и maximum.

QString QFutureWatcher::progressText() const

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

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

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

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

int QFutureWatcher::progressValue() const

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

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

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

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

T QFutureWatcher::result() const

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

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

T QFutureWatcher::resultAt(int index) const

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

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

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

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

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

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

[slot] void QFutureWatcher::resume()

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

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

[signal] void QFutureWatcher::resumed()

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

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

Начинает наблюдение за заданным future.

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

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

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

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

Если paused имеет значение true, эта функция приостанавливает асинхронное вычисление, представленное задачей (future). Если вычисление уже приостановлено, функция ничего не делает. Этот 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()).