qfuturewatcher.cpp

Go to the documentation of this file.

// Copyright (C) 2016 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
 
#include "qfuturewatcher.h"
#include "qfuturewatcher_p.h"
 
#include <QtCore/qcoreevent.h>
#include <QtCore/qcoreapplication.h>
#include <QtCore/qmetaobject.h>
#include <QtCore/qthread.h>
 
QT_BEGIN_NAMESPACE
 
QFutureWatcherBase::QFutureWatcherBase(QObject *parent)
    :QObject(*new QFutureWatcherBasePrivate, parent)
{ }
 
void QFutureWatcherBase::cancel()
{
    futureInterface().cancel();
}
 
#if QT_DEPRECATED_SINCE(6, 0)
void QFutureWatcherBase::setPaused(bool paused)
{
    futureInterface().setSuspended(paused);
}
 
void QFutureWatcherBase::pause()
{
    futureInterface().setSuspended(true);
}
 
#endif // QT_DEPRECATED_SINCE(6, 0)
 
void QFutureWatcherBase::setSuspended(bool suspend)
{
    futureInterface().setSuspended(suspend);
}
 
void QFutureWatcherBase::suspend()
{
    futureInterface().setSuspended(true);
}
 
void QFutureWatcherBase::resume()
{
    futureInterface().setSuspended(false);
}
 
#if QT_DEPRECATED_SINCE(6, 0)
void QFutureWatcherBase::togglePaused()
{
    futureInterface().toggleSuspended();
}
#endif // QT_DEPRECATED_SINCE(6, 0)
 
void QFutureWatcherBase::toggleSuspended()
{
    futureInterface().toggleSuspended();
}
 
int QFutureWatcherBase::progressValue() const
{
    return futureInterface().progressValue();
}
 
int QFutureWatcherBase::progressMinimum() const
{
    return futureInterface().progressMinimum();
}
 
int QFutureWatcherBase::progressMaximum() const
{
    return futureInterface().progressMaximum();
}
 
QString QFutureWatcherBase::progressText() const
{
    return futureInterface().progressText();
}
 
bool QFutureWatcherBase::isStarted() const
{
    return futureInterface().queryState(QFutureInterfaceBase::Started);
}
 
bool QFutureWatcherBase::isFinished() const
{
    return futureInterface().isFinished();
}
 
bool QFutureWatcherBase::isRunning() const
{
    return futureInterface().queryState(QFutureInterfaceBase::Running);
}
 
bool QFutureWatcherBase::isCanceled() const
{
    return futureInterface().queryState(QFutureInterfaceBase::Canceled);
}
 
#if QT_DEPRECATED_SINCE(6, 0)
 
bool QFutureWatcherBase::isPaused() const
{
QT_WARNING_PUSH
QT_WARNING_DISABLE_DEPRECATED
    return futureInterface().isPaused();
QT_WARNING_POP
}
#endif // QT_DEPRECATED_SINCE(6, 0)
 
bool QFutureWatcherBase::isSuspending() const
{
    return futureInterface().isSuspending();
}
 
bool QFutureWatcherBase::isSuspended() const
{
    return futureInterface().isSuspended();
}
 
void QFutureWatcherBase::waitForFinished()
{
    futureInterface().waitForFinished();
}
 
bool QFutureWatcherBase::event(QEvent *event)
{
    Q_D(QFutureWatcherBase);
    if (event->type() == QEvent::FutureCallOut) {
        QFutureCallOutEvent *callOutEvent = static_cast<QFutureCallOutEvent *>(event);
        d->sendCallOutEvent(callOutEvent);
        return true;
    }
    return QObject::event(event);
}
 
void QFutureWatcherBase::setPendingResultsLimit(int limit)
{
    Q_D(QFutureWatcherBase);
    d->maximumPendingResultsReady = limit;
}
 
void QFutureWatcherBase::connectNotify(const QMetaMethod &signal)
{
    Q_D(QFutureWatcherBase);
    static const QMetaMethod resultReadyAtSignal = QMetaMethod::fromSignal(&QFutureWatcherBase::resultReadyAt);
    if (signal == resultReadyAtSignal)
        d->resultAtConnected.ref();
#ifndef QT_NO_DEBUG
    static const QMetaMethod finishedSignal = QMetaMethod::fromSignal(&QFutureWatcherBase::finished);
    if (signal == finishedSignal) {
        if (futureInterface().isRunning()) {
            //connections should be established before calling stFuture to avoid race.
            // (The future could finish before the connection is made.)
            qWarning("QFutureWatcher::connect: connecting after calling setFuture() is likely to produce race");
        }
    }
#endif
}
 
void QFutureWatcherBase::disconnectNotify(const QMetaMethod &signal)
{
    Q_D(QFutureWatcherBase);
    static const QMetaMethod resultReadyAtSignal = QMetaMethod::fromSignal(&QFutureWatcherBase::resultReadyAt);
    if (signal == resultReadyAtSignal)
        d->resultAtConnected.deref();
}
 
QFutureWatcherBasePrivate::QFutureWatcherBasePrivate()
    : maximumPendingResultsReady(QThread::idealThreadCount() * 2),
      resultAtConnected(0)
{ }
 
void QFutureWatcherBase::connectOutputInterface()
{
    futureInterface().d->connectOutputInterface(d_func());
}
 
void QFutureWatcherBase::disconnectOutputInterface(bool pendingAssignment)
{
    if (pendingAssignment) {
        Q_D(QFutureWatcherBase);
        d->pendingResultsReady.storeRelaxed(0);
    }
 
    futureInterface().d->disconnectOutputInterface(d_func());
}
 
void QFutureWatcherBasePrivate::postCallOutEvent(const QFutureCallOutEvent &callOutEvent)
{
    Q_Q(QFutureWatcherBase);
 
    if (callOutEvent.callOutType == QFutureCallOutEvent::ResultsReady) {
        if (pendingResultsReady.fetchAndAddRelaxed(1) >= maximumPendingResultsReady)
            q->futureInterface().d->internal_setThrottled(true);
    }
 
    QCoreApplication::postEvent(q, callOutEvent.clone());
}
 
void QFutureWatcherBasePrivate::callOutInterfaceDisconnected()
{
    QCoreApplication::removePostedEvents(q_func(), QEvent::FutureCallOut);
}
 
void QFutureWatcherBasePrivate::sendCallOutEvent(QFutureCallOutEvent *event)
{
    Q_Q(QFutureWatcherBase);
 
    switch (event->callOutType) {
        case QFutureCallOutEvent::Started:
            emit q->started();
        break;
        case QFutureCallOutEvent::Finished:
            emit q->finished();
        break;
        case QFutureCallOutEvent::Canceled:
            pendingResultsReady.storeRelaxed(0);
            emit q->canceled();
        break;
        case QFutureCallOutEvent::Suspending:
            if (q->futureInterface().isCanceled())
                break;
            emit q->suspending();
#if QT_DEPRECATED_SINCE(6, 0)
QT_WARNING_PUSH
QT_WARNING_DISABLE_DEPRECATED
            emit q->paused();
QT_WARNING_POP
#endif
        break;
        case QFutureCallOutEvent::Suspended:
            if (q->futureInterface().isCanceled())
                break;
            emit q->suspended();
        break;
        case QFutureCallOutEvent::Resumed:
            if (q->futureInterface().isCanceled())
                break;
            emit q->resumed();
        break;
        case QFutureCallOutEvent::ResultsReady: {
            if (q->futureInterface().isCanceled())
                break;
 
            if (pendingResultsReady.fetchAndAddRelaxed(-1) <= maximumPendingResultsReady)
                q->futureInterface().setThrottled(false);
 
            const int beginIndex = event->index1;
            const int endIndex = event->index2;
 
            emit q->resultsReadyAt(beginIndex, endIndex);
 
            if (resultAtConnected.loadRelaxed() <= 0)
                break;
 
            for (int i = beginIndex; i < endIndex; ++i)
                emit q->resultReadyAt(i);
 
        } break;
        case QFutureCallOutEvent::Progress:
            if (q->futureInterface().isCanceled())
                break;
 
            emit q->progressValueChanged(event->index1);
            if (!event->text.isNull()) // ###
                emit q->progressTextChanged(event->text);
        break;
        case QFutureCallOutEvent::ProgressRange:
            emit q->progressRangeChanged(event->index1, event->index2);
        break;
        default: break;
    }
}
 
 
#if QT_DEPRECATED_SINCE(6, 0)
#endif // QT_DEPRECATED_SINCE(6, 0)
 
QT_END_NAMESPACE
 
#include "moc_qfuturewatcher.cpp"