qsignalspy.cpp

Go to the documentation of this file.

// Copyright (C) 2019 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 "qsignalspy.h"
 
QT_BEGIN_NAMESPACE
 
bool QSignalSpy::wait(std::chrono::milliseconds timeout)
{
    QMutexLocker locker(&m_mutex);
    Q_ASSERT(!m_waiting);
    const qsizetype origCount = size();
    m_waiting = true;
    locker.unlock();
 
    m_loop.enterLoop(timeout);
 
    locker.relock();
    m_waiting = false;
    return size() > origCount;
}
 
static bool isSignalMetaMethodValid(QMetaMethod signal)
{
    if (!signal.isValid()) {
        qWarning("QSignalSpy: Null signal is not valid");
        return false;
    }
 
    if (signal.methodType() != QMetaMethod::Signal) {
        qWarning("QSignalSpy: Not a signal: '%s'", signal.methodSignature().constData());
        return false;
    }
 
    return true;
}
 
static bool isObjectValid(const QObject *object)
{
    const bool valid = !!object;
 
    if (!valid)
        qWarning("QSignalSpy: Cannot spy on a null object");
 
    return valid;
}
 
QSignalSpy::ObjectSignal QSignalSpy::verify(const QObject *obj, const char *aSignal)
{
    if (!isObjectValid(obj))
        return {};
 
    if (!aSignal) {
        qWarning("QSignalSpy: Null signal name is not valid");
        return {};
    }
 
    if (((aSignal[0] - '0') & 0x03) != QSIGNAL_CODE) {
        qWarning("QSignalSpy: Not a valid signal, use the SIGNAL macro");
        return {};
    }
 
    const QByteArray ba = QMetaObject::normalizedSignature(aSignal + 1);
    const QMetaObject * const mo = obj->metaObject();
    const int sigIndex = mo->indexOfMethod(ba.constData());
    if (sigIndex < 0) {
        qWarning("QSignalSpy: No such signal: '%s'", ba.constData());
        return {};
    }
 
    return verify(obj, mo->method(sigIndex));
}
 
QSignalSpy::ObjectSignal QSignalSpy::verify(const QObject *obj, QMetaMethod signal)
{
    if (isObjectValid(obj) && isSignalMetaMethodValid(signal))
        return {obj, signal};
    else
        return {};
}
 
static QList<int> makeArgs(QMetaMethod member, const QObject *obj)
{
    QList<int> result;
    result.reserve(member.parameterCount());
    for (int i = 0; i < member.parameterCount(); ++i) {
        QMetaType tp = member.parameterMetaType(i);
        if (!tp.isValid() && obj) {
            void *argv[] = { &tp, &i };
            QMetaObject::metacall(const_cast<QObject*>(obj),
                                  QMetaObject::RegisterMethodArgumentMetaType,
                                  member.methodIndex(), argv);
        }
        if (!tp.isValid()) {
            qWarning("QSignalSpy: Unable to handle parameter '%s' of type '%s' of method '%s',"
                     " use qRegisterMetaType to register it.",
                     member.parameterNames().at(i).constData(),
                     member.parameterTypes().at(i).constData(),
                     member.name().constData());
        }
        result.append(tp.id());
    }
    return result;
}
 
class QSignalSpyPrivate : public QObject
{
    QSignalSpy * const q;
public:
    explicit QSignalSpyPrivate(QSignalSpy *qq) : q(qq) {}
 
    int qt_metacall(QMetaObject::Call call, int methodId, void **a) override;
};
 
QSignalSpy::QSignalSpy(ObjectSignal os)
    : sig(os.sig.methodSignature()),
      args(os.obj ? makeArgs(os.sig, os.obj) : QList<int>{})
{
    if (!os.obj)
        return;
 
    auto i = std::make_unique<QSignalSpyPrivate>(this);
 
    const auto signalIndex = os.sig.methodIndex();
    const auto slotIndex = QObject::staticMetaObject.methodCount();
    if (!QMetaObject::connect(os.obj, signalIndex,
                              i.get(), slotIndex, Qt::DirectConnection)) {
        qWarning("QSignalSpy: QMetaObject::connect returned false. Unable to connect.");
        return;
    }
 
    d_ptr = std::move(i);
}
 
QSignalSpy::~QSignalSpy()
    = default;
 
void QSignalSpy::appendArgs(void **a)
{
    QList<QVariant> list;
    list.reserve(args.size());
    for (qsizetype i = 0; i < args.size(); ++i) {
        const QMetaType::Type type = static_cast<QMetaType::Type>(args.at(i));
        if (type == QMetaType::QVariant)
            list << *reinterpret_cast<QVariant *>(a[i + 1]);
        else
            list << QVariant(QMetaType(type), a[i + 1]);
    }
    QMutexLocker locker(&m_mutex);
    append(std::move(list));
 
    if (m_waiting) {
        locker.unlock();
        m_loop.exitLoop();
    }
}
 
int QSignalSpyPrivate::qt_metacall(QMetaObject::Call call, int methodId, void **a)
{
    methodId = QObject::qt_metacall(call, methodId, a);
    if (methodId < 0)
        return methodId;
 
    if (call == QMetaObject::InvokeMetaMethod) {
        if (methodId == 0) {
            q->appendArgs(a);
        }
        --methodId;
    }
    return methodId;
}
 
QT_END_NAMESPACE