Класс QFutureWatcher

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

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

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

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

• 12 открытых функций, унаследованных от QFutureWatcherBase
• 31 открытых функций, унаследованных от 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 = 0)

Создаёт новый 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()).