QPromise Class

Dokumentation zu Member-Funktionen

[default] QPromise::QPromise()

Erstellt ein QPromise mit einem Standardzustand.

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

Erstellt eine Instanz von „ QPromise “ durch Kopieren. Diese Funktion wurde gelöscht.

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

„Move“ erstellt ein neues `QPromise` aus ` other`.

Siehe auch ` operator=()`.

QPromise::~QPromise()

Löst das Promise auf.

Entspricht

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

oder, falls index == -1 (Standard)

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

Siehe auch ` emplaceResultAt()`, ` emplaceResult()` und ` addResults()`.

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

Fügt „ results “ am Ende der internen Ergebnissammlung hinzu.

Gibt „ true “ zurück, wenn „ results “ zur Sammlung hinzugefügt wurden.

Gibt „ false “ zurück, wenn sich dieses Promise im Status „canceled“ oder „finished“ befindet.

Dies ist effizienter als eine Schleife über ` addResult()` zu durchlaufen, da zugehörige Futures nur einmal pro Aufruf von `addResults()` benachrichtigt werden, anstatt einmal pro Element in ` results`, wie es bei einzelnen Aufrufen von ` addResult()` der Fall wäre. Wenn die Berechnung jedes Elements jedoch Zeit in Anspruch nimmt, kann der Code auf der Empfängerseite (Future) erst dann fortfahren, wenn alle Ergebnisse gemeldet wurden. Verwenden Sie diese Funktion daher nur, wenn die Berechnung aufeinanderfolgender Elemente relativ schnell erfolgt.

Diese Funktion wurde in Qt 6.6 eingeführt.

Siehe auch addResult().

Fügt ein aus ` args... ` erstelltes Ergebnis an der Position ` index ` (emplaceResultAt()) oder am Ende der Sammlung (emplaceResult()) zur internen Ergebnissammlung hinzu.

Gibt ` true ` zurück, wenn das Ergebnis zur Sammlung hinzugefügt wurde.

Gibt „ false “ zurück, wenn sich dieses Promise im Status „canceled“ oder „finished“ befindet oder wenn das Ergebnis abgelehnt wurde. „ addResult()“ lehnt das Hinzufügen eines Ergebnisses ab, wenn sich bereits ein anderes Ergebnis an derselben Indexposition in der Sammlung befindet.

Diese Funktionen sind nur an der Auflösung von Überladungen beteiligt, wenn „ T “ aus args....

Sie können ein Ergebnis an einem bestimmten Index abrufen, indem Sie QFuture::resultAt() aufrufen.

Diese Funktionen wurden in Qt 6.6 eingeführt.

Siehe auch „ addResult()“ und „ addResults()“.

void QPromise::finish()

Meldet, dass die Berechnung abgeschlossen ist. Nach Abschluss der Berechnung werden beim Aufruf von „ addResult()“ keine neuen Ergebnisse mehr hinzugefügt. Diese Methode ergänzt „ start()“.

Siehe auch QFuture::isFinished(), QFuture::waitForFinished() und start().

QFuture<T> QPromise::future() const

Gibt ein mit diesem Promise verknüpftes Future zurück.

bool QPromise::isCanceled() const

Gibt zurück, ob die Berechnung mit der Funktion ` QFuture::cancel()` abgebrochen wurde. Der Rückgabewert ` true ` zeigt an, dass die Berechnung beendet und ` finish()` aufgerufen werden sollte.

void QPromise::setException(const QException &e)

Setzt die Ausnahme „ e “ als Ergebnis der Berechnung.

Siehe auch ` isCanceled()`.

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

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

Legt den Fortschrittsbereich der Berechnung auf den Bereich zwischen minimum und maximum fest.

Ist maximum kleiner als minimum, ist minimum der einzig zulässige Wert.

Der Fortschrittswert wird auf minimum zurückgesetzt.

Die Verwendung des Fortschrittsbereichs kann mit `setProgressRange(0, 0)` deaktiviert werden. In diesem Fall wird der Fortschrittswert ebenfalls auf 0 zurückgesetzt.

Siehe auch „ QFuture::progressMinimum()“, „ QFuture::progressMaximum()“ und „ QFuture::progressValue()“.

void QPromise::setProgressValue(int progressValue)

Setzt den Fortschrittswert der Berechnung auf „ progressValue “. Es ist nur möglich, den Fortschrittswert zu erhöhen. Dies ist eine Komfortmethode zum Aufruf von „ setProgressValueAndText(progressValue, QString())“.

Falls der Wert „ progressValue “ außerhalb des Fortschrittsbereichs liegt, hat diese Methode keine Wirkung.

Siehe auch ` QFuture::progressValue()` und ` setProgressRange()`.

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

Setzt den Fortschrittswert und den Fortschrittstext der Berechnung auf „ progressValue “ bzw. „ progressText “. Es ist möglich, nur den Fortschrittswert zu erhöhen.

Siehe auch QFuture::progressValue(), QFuture::progressText(), QFuture::cancel() und finish().

void QPromise::start()

Meldet, dass die Berechnung gestartet wurde. Der Aufruf dieser Methode ist wichtig, um den Beginn der Berechnung zu kennzeichnen, da die Methoden von ` QFuture ` auf diese Information angewiesen sind.

Siehe auch ` QFuture::isStarted()`, ` QFuture::waitForFinished()` und ` finish()`.

void QPromise::suspendIfRequested()

Hält den aktuellen Ausführungsthread bedingt an und wartet, bis er durch die entsprechenden Methoden von ` QFuture` wieder aufgenommen oder abgebrochen wird. Diese Methode blockiert nicht, es sei denn, die Berechnung soll durch ` QFuture::suspend()` oder eine andere verwandte Methode angehalten werden. Wenn Sie überprüfen möchten, ob die Ausführung angehalten wurde, verwenden Sie ` QFuture::isSuspended()`.

Die folgenden Codeausschnitte veranschaulichen die Verwendung des Unterbrechungsmechanismus:

    // 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() fordert das zugehörige Promise auf, die Ausführung auszusetzen:

    future.suspend();

Nachdem aus „ QFuture::isSuspended()“ „ true “ geworden ist, können Sie Zwischenergebnisse abrufen:

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

Im angehaltenen Zustand können Sie die ausstehende Berechnung fortsetzen oder abbrechen:

    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

Siehe auch „ QFuture::resume()“, „ QFuture::cancel()“, „ QFuture::setSuspended()“ und „ QFuture::toggleSuspended()“.

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

Ersetzt dieses Versprechen durch „ other “. Dieser Vorgang ist sehr schnell und schlägt niemals fehl.

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

Mit „move“ wird „ other “ diesem Promise zugewiesen und eine Referenz auf dieses Promise zurückgegeben.

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

other Weist dieser Instanz von „ QPromise “ den Wert „ “ zu. Diese Funktion wird gelöscht.