qeventloop.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 "qeventloop.h"
 
#include "qabstracteventdispatcher.h"
#include "qcoreapplication.h"
#include "qcoreapplication_p.h"
#include "qdeadlinetimer.h"
 
#include "qobject_p.h"
#include "qeventloop_p.h"
#include <private/qthread_p.h>
 
QT_BEGIN_NAMESPACE
 
QEventLoop::QEventLoop(QObject *parent)
    : QObject(*new QEventLoopPrivate, parent)
{
    Q_D(QEventLoop);
    if (!QCoreApplication::instance() && QCoreApplicationPrivate::threadRequiresCoreApplication()) {
        qWarning("QEventLoop: Cannot be used without QApplication");
    } else {
        d->threadData.loadRelaxed()->ensureEventDispatcher();
    }
}
 
QEventLoop::~QEventLoop()
{ }
 
 
bool QEventLoop::processEvents(ProcessEventsFlags flags)
{
    Q_D(QEventLoop);
    auto threadData = d->threadData.loadRelaxed();
    if (!threadData->hasEventDispatcher())
        return false;
    return threadData->eventDispatcher.loadRelaxed()->processEvents(flags);
}
 
int QEventLoop::exec(ProcessEventsFlags flags)
{
    Q_D(QEventLoop);
    auto threadData = d->threadData.loadRelaxed();
 
    //we need to protect from race condition with QThread::exit
    QMutexLocker locker(&static_cast<QThreadPrivate *>(QObjectPrivate::get(threadData->thread.loadAcquire()))->mutex);
    if (threadData->quitNow)
        return -1;
 
    if (d->inExec) {
        qWarning("QEventLoop::exec: instance %p has already called exec()", this);
        return -1;
    }
 
    struct LoopReference {
        QEventLoopPrivate *d;
        QMutexLocker<QMutex> &locker;
 
        bool exceptionCaught;
        LoopReference(QEventLoopPrivate *d, QMutexLocker<QMutex> &locker) : d(d), locker(locker), exceptionCaught(true)
        {
            d->inExec = true;
            d->exit.storeRelease(false);
 
            auto threadData = d->threadData.loadRelaxed();
            ++threadData->loopLevel;
            threadData->eventLoops.push(d->q_func());
 
            locker.unlock();
        }
 
        ~LoopReference()
        {
            if (exceptionCaught) {
                qWarning("Qt has caught an exception thrown from an event handler. Throwing\n"
                         "exceptions from an event handler is not supported in Qt.\n"
                         "You must not let any exception whatsoever propagate through Qt code.");
            }
            locker.relock();
            auto threadData = d->threadData.loadRelaxed();
            QEventLoop *eventLoop = threadData->eventLoops.pop();
            Q_ASSERT_X(eventLoop == d->q_func(), "QEventLoop::exec()", "internal error");
            Q_UNUSED(eventLoop); // --release warning
            d->inExec = false;
            --threadData->loopLevel;
        }
    };
    LoopReference ref(d, locker);
 
    // remove posted quit events when entering a new event loop
    QCoreApplication *app = QCoreApplication::instance();
    if (app && app->thread() == thread())
        QCoreApplication::removePostedEvents(app, QEvent::Quit);
 
    while (!d->exit.loadAcquire())
        processEvents(flags | WaitForMoreEvents | EventLoopExec);
 
    ref.exceptionCaught = false;
    return d->returnCode.loadRelaxed();
}
 
void QEventLoop::processEvents(ProcessEventsFlags flags, int maxTime)
{
    processEvents(flags, QDeadlineTimer(maxTime));
}
 
void QEventLoop::processEvents(ProcessEventsFlags flags, QDeadlineTimer deadline)
{
    Q_D(QEventLoop);
    if (!d->threadData.loadRelaxed()->hasEventDispatcher())
        return;
 
    while (processEvents(flags & ~WaitForMoreEvents)) {
        if (deadline.hasExpired())
            break;
    }
}
 
void QEventLoop::exit(int returnCode)
{
    Q_D(QEventLoop);
    auto threadData = d->threadData.loadAcquire();
    if (!threadData->hasEventDispatcher())
        return;
 
    d->returnCode.storeRelaxed(returnCode);
    d->exit.storeRelease(true);
    threadData->eventDispatcher.loadRelaxed()->interrupt();
}
 
bool QEventLoop::isRunning() const
{
    Q_D(const QEventLoop);
    return !d->exit.loadAcquire();
}
 
void QEventLoop::wakeUp()
{
    Q_D(QEventLoop);
    auto threadData = d->threadData.loadAcquire();
    if (!threadData->hasEventDispatcher())
        return;
    threadData->eventDispatcher.loadRelaxed()->wakeUp();
}
 
 
bool QEventLoop::event(QEvent *event)
{
    if (event->type() == QEvent::Quit) {
        quit();
        return true;
    } else {
        return QObject::event(event);
    }
}
 
void QEventLoop::quit()
{ exit(0); }
 
// If any of these trigger, the Type bits will interfere with the pointer values:
static_assert(alignof(QEventLoop) >= 4);
static_assert(alignof(QThread) >= 4);
static_assert(alignof(QCoreApplication) >= 4);
 
QEventLoopLocker::QEventLoopLocker() noexcept
    : QEventLoopLocker{QCoreApplication::instance(), Type::Application}
{
 
}
 
QEventLoopLocker::QEventLoopLocker(QEventLoop *loop) noexcept
    : QEventLoopLocker{loop, Type::EventLoop}
{
 
}
 
QEventLoopLocker::QEventLoopLocker(QThread *thread) noexcept
    : QEventLoopLocker{thread, Type::Thread}
{
 
}
 
QEventLoopLocker::~QEventLoopLocker()
{
    visit([](auto p) { p->d_func()->deref(); });
}
 
QEventLoopLocker::QEventLoopLocker(void *ptr, Type t) noexcept
    : p{quintptr(ptr) | quintptr(t)}
{
    visit([](auto p) { p->d_func()->ref(); });
}
 
template <typename Func>
void QEventLoopLocker::visit(Func f) const
{
    const auto ptr = pointer();
    if (!ptr)
        return;
    switch (type()) {
    case Type::EventLoop:   return f(static_cast<QEventLoop *>(ptr));
    case Type::Thread:      return f(static_cast<QThread *>(ptr));
    case Type::Application: return f(static_cast<QCoreApplication *>(ptr));
    }
    Q_UNREACHABLE();
}
 
QT_END_NAMESPACE
 
#include "moc_qeventloop.cpp"