qcoreevent.cpp

Go to the documentation of this file.

// Copyright (C) 2022 The Qt Company Ltd.
// Copyright (C) 2016 Intel Corporation.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
 
#include "qcoreevent.h"
#include "qcoreevent_p.h"
#include "qcoreapplication.h"
#include "qcoreapplication_p.h"
 
#include "qbasicatomic.h"
 
#include <qtcore_tracepoints_p.h>
 
#include <limits>
 
QT_BEGIN_NAMESPACE
 
Q_TRACE_POINT(qtcore, QEvent_ctor, QEvent *event, QEvent::Type type);
Q_TRACE_POINT(qtcore, QEvent_dtor, QEvent *event, QEvent::Type type);
 
QEvent::QEvent(Type type)
    : t(type), m_reserved(0),
      m_inputEvent(false), m_pointerEvent(false), m_singlePointEvent(false)
{
    Q_TRACE(QEvent_ctor, this, type);
}
 
QEvent::~QEvent()
{
    if (m_posted && QCoreApplication::instance())
        QCoreApplicationPrivate::removePostedEvent(this);
}
 
QEvent *QEvent::clone() const
{ return new QEvent(*this); }
 
namespace {
template <size_t N>
struct QBasicAtomicBitField {
    enum {
        BitsPerInt = std::numeric_limits<uint>::digits,
        NumInts = (N + BitsPerInt - 1) / BitsPerInt,
        NumBits = N
    };
 
    // This atomic int points to the next (possibly) free ID saving
    // the otherwise necessary scan through 'data':
    QBasicAtomicInteger<uint> next;
    QBasicAtomicInteger<uint> data[NumInts];
 
    constexpr QBasicAtomicBitField() = default;
 
    bool allocateSpecific(int which) noexcept
    {
        QBasicAtomicInteger<uint> &entry = data[which / BitsPerInt];
        const uint old = entry.loadRelaxed();
        const uint bit = 1U << (which % BitsPerInt);
        if (old & bit)
            return false;       // already taken
        return (entry.fetchAndOrRelaxed(bit) & bit) == 0;
 
        // don't update 'next' here - it's unlikely that it will need
        // to be updated, in the general case, and having 'next'
        // trailing a bit is not a problem, as it is just a starting
        // hint for allocateNext(), which, when wrong, will just
        // result in a few more rounds through the allocateNext()
        // loop.
    }
 
    int allocateNext() noexcept
    {
        // Unroll loop to iterate over ints, then bits? Would save
        // potentially a lot of cmpxchgs, because we can scan the
        // whole int before having to load it again.
 
        // Then again, this should never execute many iterations, so
        // leave like this for now:
        for (uint i = next.loadRelaxed(); i < NumBits; ++i) {
            if (allocateSpecific(i)) {
                // remember next (possibly) free id:
                const uint oldNext = next.loadRelaxed();
                next.testAndSetRelaxed(oldNext, qMax(i + 1, oldNext));
                return i;
            }
        }
        return -1;
    }
};
 
} // unnamed namespace
 
typedef QBasicAtomicBitField<QEvent::MaxUser - QEvent::User + 1> UserEventTypeRegistry;
 
Q_CONSTINIT static UserEventTypeRegistry userEventTypeRegistry {};
 
static inline int registerEventTypeZeroBased(int id) noexcept
{
    // if the type hint hasn't been registered yet, take it:
    if (id < UserEventTypeRegistry::NumBits && id >= 0 && userEventTypeRegistry.allocateSpecific(id))
        return id;
 
    // otherwise, ignore hint:
    return userEventTypeRegistry.allocateNext();
}
 
int QEvent::registerEventType(int hint) noexcept
{
    const int result = registerEventTypeZeroBased(QEvent::MaxUser - hint);
    return result < 0 ? -1 : QEvent::MaxUser - result ;
}
 
QTimerEvent::QTimerEvent(int timerId)
    : QEvent(Timer), id(timerId)
{}
 
Q_IMPL_EVENT_COMMON(QTimerEvent)
 
 
QChildEvent::QChildEvent(Type type, QObject *child)
    : QEvent(type), c(child)
{}
 
Q_IMPL_EVENT_COMMON(QChildEvent)
 
 
QDynamicPropertyChangeEvent::QDynamicPropertyChangeEvent(const QByteArray &name)
    : QEvent(QEvent::DynamicPropertyChange), n(name)
{
}
 
Q_IMPL_EVENT_COMMON(QDynamicPropertyChangeEvent)
 
 
QDeferredDeleteEvent::QDeferredDeleteEvent(int loopLevel, int scopeLevel)
    : QEvent(QEvent::DeferredDelete), m_loopLevel(loopLevel), m_scopeLevel(scopeLevel)
{ }
 
Q_IMPL_EVENT_COMMON(QDeferredDeleteEvent)
 
QT_END_NAMESPACE
 
#include "moc_qcoreevent.cpp"