qqmlcontextdata_p.h

Go to the documentation of this file.

// Copyright (C) 2020 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
 
#ifndef QQMLCONTEXTDATA_P_H
#define QQMLCONTEXTDATA_P_H
 
//
//  W A R N I N G
//  -------------
//
// This file is not part of the Qt API.  It exists purely as an
// implementation detail.  This header file may change from version to
// version without notice, or even be removed.
//
// We mean it.
//
 
#include <QtQml/private/qtqmlglobal_p.h>
#include <QtQml/private/qqmlcontext_p.h>
#include <QtQml/private/qqmlguard_p.h>
#include <QtQml/private/qqmltypenamecache_p.h>
#include <QtQml/private/qqmlnotifier_p.h>
#include <QtQml/private/qv4identifierhash_p.h>
#include <QtQml/private/qv4executablecompilationunit_p.h>
 
QT_BEGIN_NAMESPACE
 
class QQmlComponentAttached;
class QQmlGuardedContextData;
class QQmlJavaScriptExpression;
class QQmlIncubatorPrivate;
 
class Q_QML_EXPORT QQmlContextData
{
public:
    static QQmlRefPointer<QQmlContextData> createRefCounted(
            const QQmlRefPointer<QQmlContextData> &parent)
    {
        return QQmlRefPointer<QQmlContextData>(new QQmlContextData(RefCounted, nullptr, parent),
                                               QQmlRefPointer<QQmlContextData>::Adopt);
    }
 
    // Owned by the parent. When the parent is reset to nullptr, it will be deref'd.
    static QQmlRefPointer<QQmlContextData> createChild(
            const QQmlRefPointer<QQmlContextData> &parent)
    {
        Q_ASSERT(!parent.isNull());
        return QQmlRefPointer<QQmlContextData>(new QQmlContextData(OwnedByParent, nullptr, parent));
    }
 
    void addref() const { ++m_refCount; }
    void release() const { if (--m_refCount == 0) delete this; }
    int count() const { return m_refCount; }
    int refCount() const { return m_refCount; }
 
    QQmlRefPointer<QV4::ExecutableCompilationUnit> typeCompilationUnit() const
    {
        return m_typeCompilationUnit;
    }
    void initFromTypeCompilationUnit(const QQmlRefPointer<QV4::ExecutableCompilationUnit> &unit,
                                     int subComponentIndex);
 
    static QQmlRefPointer<QQmlContextData> get(QQmlContext *context) {
        return QQmlContextPrivate::get(context)->m_data;
    }
 
    void emitDestruction();
    void clearContext();
    void clearContextRecursively();
    void invalidate();
 
    bool isValid() const
    {
        return m_engine && (!m_isInternal || !m_contextObject
                            || !QObjectPrivate::get(m_contextObject)->wasDeleted);
    }
 
    bool isInternal() const { return m_isInternal; }
    void setInternal(bool isInternal) { m_isInternal = isInternal; }
 
    bool isJSContext() const { return m_isJSContext; }
    void setJSContext(bool isJSContext) { m_isJSContext = isJSContext; }
 
    bool isPragmaLibraryContext() const { return m_isPragmaLibraryContext; }
    void setPragmaLibraryContext(bool library) { m_isPragmaLibraryContext = library; }
 
    QQmlRefPointer<QQmlContextData> parent() const { return m_parent; }
    void clearParent()
    {
        if (!m_parent)
            return;
 
        m_parent = nullptr;
        if (m_ownedByParent) {
            m_ownedByParent = false;
            release();
        }
    }
 
    void refreshExpressions();
 
    void addOwnedObject(QQmlData *ownedObject);
    QQmlData *ownedObjects() const { return m_ownedObjects; }
    void setOwnedObjects(QQmlData *ownedObjects) { m_ownedObjects = ownedObjects; }
 
    enum QmlObjectKind {
        OrdinaryObject,
        DocumentRoot,
    };
    void installContext(QQmlData *ddata, QmlObjectKind kind);
 
    QUrl resolvedUrl(const QUrl &) const;
 
    // My containing QQmlContext.  If isInternal is true this owns publicContext.
    // If internal is false publicContext owns this.
    QQmlContext *asQQmlContext()
    {
        if (!m_publicContext)
            m_publicContext = new QQmlContext(*new QQmlContextPrivate(this));
        return m_publicContext;
    }
 
    QQmlContextPrivate *asQQmlContextPrivate()
    {
        return QQmlContextPrivate::get(asQQmlContext());
    }
 
    QObject *contextObject() const { return m_contextObject; }
    void setContextObject(QObject *contextObject) { m_contextObject = contextObject; }
 
    template<typename HandleSelf, typename HandleLinked>
    void deepClearContextObject(
            QObject *contextObject, HandleSelf &&handleSelf, HandleLinked &&handleLinked) {
        for (QQmlContextData *lc = m_linkedContext.data(); lc; lc = lc->m_linkedContext.data()) {
            handleLinked(lc);
            if (lc->m_contextObject == contextObject)
                lc->m_contextObject = nullptr;
        }
 
        handleSelf(this);
        if (m_contextObject == contextObject)
            m_contextObject = nullptr;
    }
 
    void deepClearContextObject(QObject *contextObject)
    {
        deepClearContextObject(
                contextObject,
                [](QQmlContextData *self) { self->emitDestruction(); },
                [](QQmlContextData *){});
    }
 
    QQmlEngine *engine() const { return m_engine; }
    void setEngine(QQmlEngine *engine) { m_engine = engine; }
 
    QQmlContext *publicContext() const { return m_publicContext; }
    void clearPublicContext()
    {
        if (!m_publicContext)
            return;
 
        m_publicContext = nullptr;
        if (m_ownedByPublicContext) {
            m_ownedByPublicContext = false;
            release();
        }
    }
 
    int propertyIndex(const QString &name) const
    {
        ensurePropertyNames();
        return m_propertyNameCache.value(name);
    }
 
    int propertyIndex(QV4::String *name) const
    {
        ensurePropertyNames();
        return m_propertyNameCache.value(name);
    }
 
    QString propertyName(int index) const
    {
        ensurePropertyNames();
        return m_propertyNameCache.findId(index);
    }
 
    void addPropertyNameAndIndex(const QString &name, int index)
    {
        Q_ASSERT(!m_propertyNameCache.isEmpty());
        m_propertyNameCache.add(name, index);
    }
 
    void setExpressions(QQmlJavaScriptExpression *expressions) { m_expressions = expressions; }
    QQmlJavaScriptExpression *takeExpressions()
    {
        QQmlJavaScriptExpression *expressions = m_expressions;
        m_expressions = nullptr;
        return expressions;
    }
 
    void setChildContexts(const QQmlRefPointer<QQmlContextData> &childContexts)
    {
        m_childContexts = childContexts.data();
    }
    QQmlRefPointer<QQmlContextData> childContexts() const { return m_childContexts; }
    QQmlRefPointer<QQmlContextData> takeChildContexts()
    {
        QQmlRefPointer<QQmlContextData> childContexts = m_childContexts;
        m_childContexts = nullptr;
        return childContexts;
    }
    QQmlRefPointer<QQmlContextData> nextChild() const { return m_nextChild; }
 
    int numIdValues() const { return m_idValueCount; }
    void setIdValue(int index, QObject *idValue);
    bool isIdValueSet(int index) const { return m_idValues[index].wasSet(); }
    QQmlNotifier *idValueBindings(int index) const { return m_idValues[index].bindings(); }
    QObject *idValue(int index) const { return m_idValues[index].data(); }
 
    // Return the outermost id for obj, if any.
    QString findObjectId(const QObject *obj) const;
 
    // url() and urlString() prefer the CU's URL over explicitly set baseUrls. They
    // don't search the context hierarchy.
    // baseUrl() and baseUrlString() search the context hierarchy and prefer explicit
    // base URLs over CU Urls.
 
    QUrl url() const;
    QString urlString() const;
 
    void setBaseUrlString(const QString &baseUrlString) { m_baseUrlString = baseUrlString; }
    QString baseUrlString() const
    {
        for (const QQmlContextData *data = this; data; data = data->m_parent) {
            if (!data->m_baseUrlString.isEmpty())
                return data->m_baseUrlString;
            if (data->m_typeCompilationUnit)
                return data->m_typeCompilationUnit->finalUrlString();
        }
        return QString();
    }
 
    void setBaseUrl(const QUrl &baseUrl) { m_baseUrl = baseUrl; }
    QUrl baseUrl() const
    {
        for (const QQmlContextData *data = this; data; data = data->m_parent) {
            if (!data->m_baseUrl.isEmpty())
                return data->m_baseUrl;
            if (data->m_typeCompilationUnit)
                return data->m_typeCompilationUnit->finalUrl();
        }
        return QUrl();
    }
 
    QQmlRefPointer<QQmlTypeNameCache> imports() const { return m_imports; }
    void setImports(const QQmlRefPointer<QQmlTypeNameCache> &imports) { m_imports = imports; }
 
    QQmlIncubatorPrivate *incubator() const { return m_hasExtraObject ? nullptr : m_incubator; }
    void setIncubator(QQmlIncubatorPrivate *incubator)
    {
        Q_ASSERT(!m_hasExtraObject || m_extraObject == nullptr);
        m_hasExtraObject = false;
        m_incubator = incubator;
    }
 
    QObject *extraObject() const { return m_hasExtraObject ? m_extraObject : nullptr; }
    void setExtraObject(QObject *extraObject)
    {
        Q_ASSERT(m_hasExtraObject || m_incubator == nullptr);
        m_hasExtraObject = true;
        m_extraObject = extraObject;
    }
 
    bool isRootObjectInCreation() const { return m_isRootObjectInCreation; }
    void setRootObjectInCreation(bool rootInCreation) { m_isRootObjectInCreation = rootInCreation; }
 
    QV4::ReturnedValue importedScripts() const
    {
        if (m_hasWeakImportedScripts)
            return m_weakImportedScripts.value();
        else
            return m_importedScripts.value();
    }
    void setImportedScripts(QV4::ExecutionEngine *engine, QV4::Value scripts) {
        // setImportedScripts should not be called on an invalidated context
        Q_ASSERT(!m_hasWeakImportedScripts);
        m_importedScripts.set(engine, scripts);
    }
 
    /*
       we can safely pass a ReturnedValue here, as setImportedScripts will directly store
       scripts in a persistentValue, without any intermediate allocation that could trigger
       a gc run
    */
    void setImportedScripts(QV4::ExecutionEngine *engine, QV4::ReturnedValue scripts) {
        // setImportedScripts should not be called on an invalidated context
        Q_ASSERT(!m_hasWeakImportedScripts);
        m_importedScripts.set(engine, scripts);
    }
 
    QQmlRefPointer<QQmlContextData> linkedContext() const { return m_linkedContext; }
    void setLinkedContext(const QQmlRefPointer<QQmlContextData> &context) { m_linkedContext = context; }
 
    bool hasUnresolvedNames() const { return m_unresolvedNames; }
    void setUnresolvedNames(bool hasUnresolvedNames) { m_unresolvedNames = hasUnresolvedNames; }
 
    QQmlComponentAttached *componentAttacheds() const { return m_componentAttacheds; }
    void addComponentAttached(QQmlComponentAttached *attached);
 
    void addExpression(QQmlJavaScriptExpression *expression);
 
    bool valueTypesAreAddressable() const {
        return m_typeCompilationUnit && m_typeCompilationUnit->valueTypesAreAddressable();
    }
 
    bool valueTypesAreAssertable() const {
        return m_typeCompilationUnit && m_typeCompilationUnit->valueTypesAreAssertable();
    }
 
private:
    friend class QQmlGuardedContextData;
    friend class QQmlContextPrivate;
 
    enum Ownership {
        RefCounted,
        OwnedByParent,
        OwnedByPublicContext
    };
 
    // id guards
    struct ContextGuard : public QQmlGuard<QObject>
    {
        enum Tag {
            NoTag,
            ObjectWasSet
        };
 
        inline ContextGuard() : QQmlGuard<QObject>(&ContextGuard::objectDestroyedImpl, nullptr), m_context(nullptr) {}
        inline ContextGuard &operator=(QObject *obj);
 
        inline bool wasSet() const;
 
        QQmlNotifier *bindings() { return &m_bindings; }
        void setContext(const QQmlRefPointer<QQmlContextData> &context)
        {
            m_context = context.data();
        }
 
    private:
        inline static void objectDestroyedImpl(QQmlGuardImpl *);
        // Not refcounted, as it always belongs to the QQmlContextData.
        QTaggedPointer<QQmlContextData, Tag> m_context;
        QQmlNotifier m_bindings;
    };
 
    // It's OK to pass a half-created publicContext here. We will not dereference it during
    // construction.
    QQmlContextData(
            Ownership ownership, QQmlContext *publicContext,
            const QQmlRefPointer<QQmlContextData> &parent,  QQmlEngine *engine = nullptr)
        : m_parent(parent.data()),
          m_engine(engine ? engine : (parent.isNull() ? nullptr : parent->engine())),
          m_isInternal(false), m_isJSContext(false), m_isPragmaLibraryContext(false),
          m_unresolvedNames(false), m_hasEmittedDestruction(false), m_isRootObjectInCreation(false),
          m_ownedByParent(ownership == OwnedByParent),
          m_ownedByPublicContext(ownership == OwnedByPublicContext), m_hasExtraObject(false),
          m_hasWeakImportedScripts(false), m_dummy(0), m_publicContext(publicContext), m_incubator(nullptr)
    {
        Q_ASSERT(!m_ownedByParent || !m_ownedByPublicContext);
        if (!m_parent)
            return;
 
        m_nextChild = m_parent->m_childContexts;
        if (m_nextChild)
            m_nextChild->m_prevChild = &m_nextChild;
        m_prevChild = &m_parent->m_childContexts;
        m_parent->m_childContexts = this;
    }
 
    ~QQmlContextData();
 
    bool hasExpressionsToRun(bool isGlobalRefresh) const
    {
        return m_expressions && (!isGlobalRefresh || m_unresolvedNames);
    }
 
    void refreshExpressionsRecursive(bool isGlobal);
    void refreshExpressionsRecursive(QQmlJavaScriptExpression *);
    void initPropertyNames() const;
 
    void ensurePropertyNames() const
    {
        if (m_propertyNameCache.isEmpty())
            initPropertyNames();
        Q_ASSERT(!m_propertyNameCache.isEmpty());
    }
 
    // My parent context and engine
    QQmlContextData *m_parent = nullptr;
    QQmlEngine *m_engine = nullptr;
 
    mutable quint32 m_refCount = 1;
    quint32 m_isInternal:1;
    quint32 m_isJSContext:1;
    quint32 m_isPragmaLibraryContext:1;
    quint32 m_unresolvedNames:1; // True if expressions in this context failed to resolve a toplevel name
    quint32 m_hasEmittedDestruction:1;
    quint32 m_isRootObjectInCreation:1;
    quint32 m_ownedByParent:1;
    quint32 m_ownedByPublicContext:1;
    quint32 m_hasExtraObject:1; // used in QQmlDelegateModelItem::dataForObject to find the corresponding QQmlDelegateModelItem of an object
    quint32 m_hasWeakImportedScripts:1;
    Q_DECL_UNUSED_MEMBER quint32 m_dummy:22;
    QQmlContext *m_publicContext = nullptr;
 
    union {
        // The incubator that is constructing this context if any
        QQmlIncubatorPrivate *m_incubator;
        // a pointer to extra data, currently only used in QQmlDelegateModel
        QObject *m_extraObject;
    };
 
    // Compilation unit for contexts that belong to a compiled type.
    QQmlRefPointer<QV4::ExecutableCompilationUnit> m_typeCompilationUnit;
 
    // object index in CompiledData::Unit to component that created this context
    int m_componentObjectIndex = -1;
 
    // flag indicates whether the context owns the cache (after mutation) or not.
    mutable QV4::IdentifierHash m_propertyNameCache;
 
    // Context object
    QObject *m_contextObject = nullptr;
 
    // Any script blocks that exist on this context
    union {
        /* an invalidated context transitions from a strong reference to the scripts
           to a weak one, so that the context doesn't needlessly holds on to the scripts,
           but closures can still access them if needed
         */
        QV4::PersistentValue m_importedScripts = {}; // This is a JS Array
        QV4::WeakValue m_weakImportedScripts;
    };
 
    QUrl m_baseUrl;
    QString m_baseUrlString;
 
    // List of imports that apply to this context
    QQmlRefPointer<QQmlTypeNameCache> m_imports;
 
    // My children, not refcounted as that would create cyclic references
    QQmlContextData *m_childContexts = nullptr;
 
    // My peers in parent's childContexts list; not refcounted
    QQmlContextData  *m_nextChild = nullptr;
    QQmlContextData **m_prevChild = nullptr;
 
    // Expressions that use this context
    QQmlJavaScriptExpression *m_expressions = nullptr;
 
    // Doubly-linked list of objects that are owned by this context
    QQmlData *m_ownedObjects = nullptr;
 
    // Doubly-linked list of context guards (XXX merge with contextObjects)
    QQmlGuardedContextData *m_contextGuards = nullptr;
 
    ContextGuard *m_idValues = nullptr;
    int m_idValueCount = 0;
 
    // Linked contexts. this owns linkedContext.
    QQmlRefPointer<QQmlContextData> m_linkedContext;
 
    // Linked list of uses of the Component attached property in this context
    QQmlComponentAttached *m_componentAttacheds = nullptr;
};
 
QQmlContextData::ContextGuard &QQmlContextData::ContextGuard::operator=(QObject *obj)
{
    QQmlGuard<QObject>::operator=(obj);
    m_context.setTag(ObjectWasSet);
    m_bindings.notify(); // For alias connections
    return *this;
}
 
 void QQmlContextData::ContextGuard::objectDestroyedImpl(QQmlGuardImpl *impl)
{
    auto This = static_cast<QQmlContextData::ContextGuard *>(impl);
    if (QObject *contextObject = This->m_context->contextObject()) {
        if (!QObjectPrivate::get(contextObject)->wasDeleted)
            This->m_bindings.notify();
    }
}
 
bool QQmlContextData::ContextGuard::wasSet() const
{
    return m_context.tag() == ObjectWasSet;
}
 
QT_END_NAMESPACE
 
#endif // QQMLCONTEXTDATA_P_H