QPromise Class

Documentation sur les fonctions membres

[default] QPromise::QPromise()

Crée un objet QPromise avec un état par défaut.

[delete] QPromise::QPromise(const QPromise<T> &)

Copie et construit une instance de ` QPromise`. Cette fonction a été supprimée.

[default] QPromise::QPromise(QPromise<T> &&other)

La fonction `Move` crée une nouvelle instance de `QPromise` à partir de ` other`.

Voir également operator=().

QPromise::~QPromise()

Annule la promesse.

Equivalent à

emplaceResultAt(index, result);            // first overload
emplaceResultAt(index, std::move(result)); // second overload

ou, si index == -1 (valeur par défaut)

emplaceResult(result);            // first overload
emplaceResult(std::move(result)); // second overload

Voir également emplaceResultAt(), emplaceResult() et addResults().

[since 6.6] bool QPromise::addResults(const QList<T> &results)

Ajoute results à la fin de la collection de résultats interne.

Renvoie true lorsque results sont ajoutés à la collection.

Renvoie false lorsque cette promesse est à l'état « canceled » ou « finished ».

Cette méthode est plus efficace qu’une boucle sur addResult(), car les futures associées ne seront notifiées qu’une seule fois par appel à addResults(), au lieu d’une fois par élément contenu dans results, comme ce serait le cas avec des appels individuels à addResult(). Cependant, si le calcul de chaque élément prend du temps, le code du côté récepteur (future) ne peut pas progresser tant que tous les résultats n’ont pas été signalés ; n’utilisez donc cette fonction que si le calcul d’éléments consécutifs est relativement rapide.

Cette fonction a été introduite dans Qt 6.6.

Voir également addResult().

Ajoute un résultat construit à partir de ` args... ` à la collection interne de résultats, à la position ` index ` (emplaceResultAt()) ou à la fin de la collection (emplaceResult()).

Renvoie true lorsque le résultat a été ajouté à la collection.

Renvoie false lorsque cette promesse est à l'état « canceled » ou « finished », ou lorsque le résultat a été rejeté. addResult() rejette l'ajout d'un résultat s'il existe déjà un autre résultat dans la collection stocké au même index.

Ces fonctions ne participent à la résolution des surcharges que si ` T ` est constructible à partir de args....

Vous pouvez récupérer un résultat à un index spécifique en appelant ` QFuture::resultAt()`.

Ces fonctions ont été introduites dans Qt 6.6.

Voir également addResult() et addResults().

void QPromise::finish()

Indique que le calcul est terminé. Une fois terminé, aucun nouveau résultat ne sera ajouté lors de l'appel de la méthode ` addResult()`. Cette méthode accompagne la méthode ` start()`.

Voir également QFuture::isFinished(), QFuture::waitForFinished() et start().

QFuture<T> QPromise::future() const

Renvoie un « future » associé à cette « promise ».

bool QPromise::isCanceled() const

Indique si le calcul a été annulé à l'aide de la fonction QFuture::cancel(). La valeur renvoyée true indique que le calcul doit être terminé et que la fonction finish() doit être appelée.

void QPromise::setException(const QException &e)

Définit l'e e d'exception comme étant le résultat du calcul.

Voir également isCanceled().

void QPromise::setException(std::__exception_ptr::exception_ptr e)

void QPromise::setProgressRange(int minimum, int maximum)

Définit la plage de progression du calcul entre minimum et maximum.

Si maximum est inférieur à minimum, minimum devient la seule valeur valide.

La valeur de progression est réinitialisée à minimum.

L'utilisation de la plage de progression peut être désactivée à l'aide de setProgressRange(0, 0). Dans ce cas, la valeur de progression est également réinitialisée à 0.

Voir également QFuture::progressMinimum(), QFuture::progressMaximum() et QFuture::progressValue().

void QPromise::setProgressValue(int progressValue)

Définit la valeur de progression du calcul sur progressValue. Seule une augmentation de la valeur de progression est autorisée. Il s'agit d'une méthode pratique permettant d'appeler setProgressValueAndText(progressValue, QString()).

Si la valeur de progression ( progressValue ) sort de la plage autorisée, cette méthode n'a aucun effet.

Voir également QFuture::progressValue() et setProgressRange().

void QPromise::setProgressValueAndText(int progressValue, const QString &progressText)

Définit respectivement la valeur de progression et le texte de progression du calcul sur progressValue et progressText. Il est possible de n'incrémenter que la valeur de progression.

Voir également QFuture::progressValue(), QFuture::progressText(), QFuture::cancel() et finish().

void QPromise::start()

Indique que le calcul a démarré. L'appel de cette méthode est important pour signaler le début du calcul, car les méthodes de l QFuture ation s'appuient sur cette information.

Voir également QFuture::isStarted(), QFuture::waitForFinished() et finish().

void QPromise::suspendIfRequested()

Suspends conditionnellement le thread d’exécution actuel et attend qu’il soit repris ou annulé par les méthodes correspondantes de ` QFuture`. Cette méthode ne bloque pas, sauf si la suspension du calcul est demandée par ` QFuture::suspend()` ou une autre méthode associée. Si vous souhaitez vérifier que l’exécution a bien été suspendue, utilisez ` QFuture::isSuspended()`.

Les extraits de code suivants illustrent l'utilisation du mécanisme de suspension :

    // Create promise and future
    QPromise<int> promise;
    QFuture<int> future = promise.future();

    promise.start();
    // Start a computation thread that supports suspension and cancellation
    const std::unique_ptr<QThread> thread(QThread::create([] (QPromise<int> promise) {
        for (int i = 0; i < 100; ++i) {
            promise.addResult(i);
            promise.suspendIfRequested();   // support suspension
            if (promise.isCanceled())       // support cancellation
                break;
        }
        promise.finish();
    }, std::move(promise)));
    thread->start();

QFuture::suspend() demande à la promesse associée de se suspendre :

    future.suspend();

Une fois que QFuture::isSuspended() devient true, vous pouvez récupérer les résultats intermédiaires :

    future.resultCount();  // returns some number between 0 and 100
    for (int i = 0; i < future.resultCount(); ++i) {
        // process results available before suspension
    }

En cas de suspension, vous pouvez reprendre ou annuler le calcul en attente :

    future.resume();  // resumes computation, this call will unblock the promise
    // alternatively, call future.cancel() to stop the computation

    future.waitForFinished();
    future.results();  // returns all computation results - array of values from 0 to 99

Voir également QFuture::resume(), QFuture::cancel(), QFuture::setSuspended() et QFuture::toggleSuspended().

[noexcept] void QPromise::swap(QPromise<T> &other)

Remplace cette promesse par other. Cette opération est très rapide et ne rate jamais.

[noexcept] QPromise<T> &QPromise::operator=(QPromise<T> &&other)

La méthode `move` attribue ` other ` à cette promesse et renvoie une référence à celle-ci.

[delete] QPromise<T> &QPromise::operator=(const QPromise<T> &)

Copie et attribue « other » à cette instance « QPromise ». Cette fonction est supprimée.