QDeclarativePropertyCache Class Reference

#include <qdeclarativepropertycache_p.h>

Inheritance diagram for QDeclarativePropertyCache:

Classes
struct	Data
struct	RData
struct	ValueTypeData

Public Functions
void	append (QDeclarativeEngine *, const QMetaObject *, Data::Flag propertyFlags=Data::NoFlags, Data::Flag methodFlags=Data::NoFlags, Data::Flag signalFlags=Data::NoFlags)
void	append (QDeclarativeEngine *, const QMetaObject *, int revision, Data::Flag propertyFlags=Data::NoFlags, Data::Flag methodFlags=Data::NoFlags, Data::Flag signalFlags=Data::NoFlags)
QDeclarativePropertyCache *	copy () const
bool	isAllowedInRevision (Data *) const
Data *	method (int) const
Data *	overrideData (Data *) const
Data *	property (const QScriptDeclarativeClass::Identifier &id) const
Data *	property (const QString &) const
Data *	property (int) const
QStringList	propertyNames () const
	QDeclarativePropertyCache (QDeclarativeEngine *)
	Creates a new empty QDeclarativePropertyCache. More...
	QDeclarativePropertyCache (QDeclarativeEngine *, const QMetaObject *)
	Creates a new QDeclarativePropertyCache of metaObject. More...
QDeclarativeEngine *	qmlEngine () const
void	update (QDeclarativeEngine *, const QMetaObject *)
virtual	~QDeclarativePropertyCache ()
Public Functions inherited from QDeclarativeRefCount
void	addref ()
	QDeclarativeRefCount ()
void	release ()
virtual	~QDeclarativeRefCount ()
Public Functions inherited from QDeclarativeCleanup
	QDeclarativeCleanup (QDeclarativeEngine *)
virtual	~QDeclarativeCleanup ()

Static Public Functions
static Data	create (const QMetaObject *, const QString &)
static Data *	property (QDeclarativeEngine *, QObject *, const QScriptDeclarativeClass::Identifier &, Data &)
static Data *	property (QDeclarativeEngine *, QObject *, const QString &, Data &)

Protected Functions
virtual void	clear ()

Private Types
typedef QVector< int >	AllowedRevisionCache
typedef QHash< QScriptDeclarativeClass::Identifier, RData * >	IdentifierCache
typedef QVector< RData * >	IndexCache
typedef QHash< QString, RData * >	StringCache

Private Functions
void	updateRecur (QDeclarativeEngine *, const QMetaObject *)

Properties
AllowedRevisionCache	allowedRevisionCache
QDeclarativeEngine *	engine
IdentifierCache	identifierCache
IndexCache	indexCache
IndexCache	methodIndexCache
StringCache	stringCache

Friends
class	QDeclarativeEnginePrivate

Detailed Description

Definition at line 68 of file qdeclarativepropertycache_p.h.

Typedefs

AllowedRevisionCache

typedef QVector<int> QDeclarativePropertyCache::AllowedRevisionCache

private

Definition at line 169 of file qdeclarativepropertycache_p.h.

IdentifierCache

typedef QHash<QScriptDeclarativeClass::Identifier, RData *> QDeclarativePropertyCache::IdentifierCache

private

Definition at line 168 of file qdeclarativepropertycache_p.h.

IndexCache

typedef QVector<RData *> QDeclarativePropertyCache::IndexCache

private

Definition at line 166 of file qdeclarativepropertycache_p.h.

StringCache

typedef QHash<QString, RData *> QDeclarativePropertyCache::StringCache

private

Definition at line 167 of file qdeclarativepropertycache_p.h.

Constructors and Destructors

QDeclarativePropertyCache() [1/2]

QDeclarativePropertyCache::QDeclarativePropertyCache

(

QDeclarativeEngine *

e

)

Creates a new empty QDeclarativePropertyCache.

Definition at line 117 of file qdeclarativepropertycache.cpp.

Referenced by copy().

: QDeclarativeCleanup(e), engine(e)
{
    Q_ASSERT(engine);
}

QDeclarativePropertyCache() [2/2]

QDeclarativePropertyCache::QDeclarativePropertyCache	(	QDeclarativeEngine *	e,
		const QMetaObject *	metaObject
	)

Creates a new QDeclarativePropertyCache of metaObject.

Definition at line 126 of file qdeclarativepropertycache.cpp.

: QDeclarativeCleanup(e), engine(e)
{
    Q_ASSERT(engine);
    Q_ASSERT(metaObject);

    update(engine, metaObject);
}

~QDeclarativePropertyCache()

QDeclarativePropertyCache::~QDeclarativePropertyCache ( )

virtual

Definition at line 135 of file qdeclarativepropertycache.cpp.

{
    clear();
}

Functions

append() [1/2]

void QDeclarativePropertyCache::append	(	QDeclarativeEngine *	engine,
		const QMetaObject *	metaObject,
		Data::Flag	propertyFlags = Data::NoFlags,
		Data::Flag	methodFlags = Data::NoFlags,
		Data::Flag	signalFlags = Data::NoFlags
	)

Definition at line 237 of file qdeclarativepropertycache.cpp.

Referenced by QDeclarativeCompiler::buildDynamicMeta(), QDeclarativeEnginePrivate::createCache(), and updateRecur().

{
    append(engine, metaObject, -1, propertyFlags, methodFlags, signalFlags);
}

append() [2/2]

void QDeclarativePropertyCache::append	(	QDeclarativeEngine *	engine,
		const QMetaObject *	metaObject,
		int	revision,
		Data::Flag	propertyFlags = Data::NoFlags,
		Data::Flag	methodFlags = Data::NoFlags,
		Data::Flag	signalFlags = Data::NoFlags
	)

Definition at line 243 of file qdeclarativepropertycache.cpp.

{
    Q_UNUSED(revision);

    allowedRevisionCache.append(0);

    QDeclarativeEnginePrivate *enginePriv = QDeclarativeEnginePrivate::get(engine);
    int methodCount = metaObject->methodCount();
    // 3 to block the destroyed signal and the deleteLater() slot
    int methodOffset = qMax(3, metaObject->methodOffset()); 

    methodIndexCache.resize(methodCount);
    for (int ii = methodOffset; ii < methodCount; ++ii) {
        QMetaMethod m = metaObject->method(ii);
        if (m.access() == QMetaMethod::Private) 
            continue;
        QString methodName = QString::fromUtf8(m.signature());

        int parenIdx = methodName.indexOf(QLatin1Char('('));
        Q_ASSERT(parenIdx != -1);
        methodName = methodName.left(parenIdx);

        RData *data = new RData;
        data->identifier = enginePriv->objectClass->createPersistentIdentifier(methodName);
        methodIndexCache[ii] = data;  

        data->load(m);
        if (m.methodType() == QMetaMethod::Slot || m.methodType() == QMetaMethod::Method) 
            data->flags |= methodFlags;
        else if (m.methodType() == QMetaMethod::Signal)
            data->flags |= signalFlags;

        data->metaObjectOffset = allowedRevisionCache.count() - 1;

        if (stringCache.contains(methodName)) {
            RData *old = stringCache[methodName];
            // We only overload methods in the same class, exactly like C++
            if (old->flags & Data::IsFunction && old->coreIndex >= methodOffset)
                data->relatedIndex = old->coreIndex;
            data->overrideIndexIsProperty = !bool(old->flags & Data::IsFunction);
            data->overrideIndex = old->coreIndex;
            stringCache[methodName]->release();
            identifierCache[data->identifier.identifier]->release();
        }

        stringCache.insert(methodName, data);
        identifierCache.insert(data->identifier.identifier, data);
        data->addref();
        data->addref();
    }

    int propCount = metaObject->propertyCount();
    int propOffset = metaObject->propertyOffset();

    indexCache.resize(propCount);
    for (int ii = propOffset; ii < propCount; ++ii) {
        QMetaProperty p = metaObject->property(ii);
        if (!p.isScriptable())
            continue;

        QString propName = QString::fromUtf8(p.name());

        RData *data = new RData;
        data->identifier = enginePriv->objectClass->createPersistentIdentifier(propName);
        indexCache[ii] = data;

        data->load(p, engine);
        data->flags |= propertyFlags;

        data->metaObjectOffset = allowedRevisionCache.count() - 1;

        if (stringCache.contains(propName)) {
            RData *old = stringCache[propName];
            data->overrideIndexIsProperty = !bool(old->flags & Data::IsFunction);
            data->overrideIndex = old->coreIndex;
            stringCache[propName]->release();
            identifierCache[data->identifier.identifier]->release();
        }

        stringCache.insert(propName, data);
        identifierCache.insert(data->identifier.identifier, data);
        data->addref();
        data->addref();
    }
}

clear()

void QDeclarativePropertyCache::clear ( )

protectedvirtual

Implements QDeclarativeCleanup.

Definition at line 140 of file qdeclarativepropertycache.cpp.

Referenced by update(), and ~QDeclarativePropertyCache().

{
    for (int ii = 0; ii < indexCache.count(); ++ii) {
        if (indexCache.at(ii)) indexCache.at(ii)->release();
    }

    for (int ii = 0; ii < methodIndexCache.count(); ++ii) {
        RData *data = methodIndexCache.at(ii);
        if (data) data->release(); 
    }

    for (StringCache::ConstIterator iter = stringCache.begin(); 
            iter != stringCache.end(); ++iter) {
        RData *data = (*iter);
        data->release(); 
    }

    for (IdentifierCache::ConstIterator iter = identifierCache.begin(); 
            iter != identifierCache.end(); ++iter) {
        RData *data = (*iter);
        data->release(); 
    }

    indexCache.clear();
    methodIndexCache.clear();
    stringCache.clear();
    identifierCache.clear();
}

copy()

QDeclarativePropertyCache * QDeclarativePropertyCache::copy

(

)

const

Definition at line 214 of file qdeclarativepropertycache.cpp.

Referenced by QDeclarativeEnginePrivate::createCache().

{
    QDeclarativePropertyCache *cache = new QDeclarativePropertyCache(engine);
    cache->indexCache = indexCache;
    cache->methodIndexCache = methodIndexCache;
    cache->stringCache = stringCache;
    cache->identifierCache = identifierCache;
    cache->allowedRevisionCache = allowedRevisionCache;

    for (int ii = 0; ii < indexCache.count(); ++ii) {
        if (indexCache.at(ii)) indexCache.at(ii)->addref();
    }
    for (int ii = 0; ii < methodIndexCache.count(); ++ii) {
        if (methodIndexCache.at(ii)) methodIndexCache.at(ii)->addref();
    }
    for (StringCache::ConstIterator iter = stringCache.begin(); iter != stringCache.end(); ++iter)
        (*iter)->addref();
    for (IdentifierCache::ConstIterator iter = identifierCache.begin(); iter != identifierCache.end(); ++iter)
        (*iter)->addref();

    return cache;
}

create()

QDeclarativePropertyCache::Data QDeclarativePropertyCache::create ( const QMetaObject *  metaObject, const QString &  property  )

static

Definition at line 169 of file qdeclarativepropertycache.cpp.

Referenced by property().

{
    Q_ASSERT(metaObject);

    QDeclarativePropertyCache::Data rv;
    {
        const QMetaObject *cmo = metaObject;
        while (cmo) {
            int idx = metaObject->indexOfProperty(property.toUtf8());
            if (idx != -1) {
                QMetaProperty p = metaObject->property(idx);
                if (p.isScriptable()) {
                    rv.load(metaObject->property(idx));
                    return rv;
                } else {
                    while (cmo && cmo->propertyOffset() >= idx)
                        cmo = cmo->superClass();
                }
            } else {
                cmo = 0;
            }
        }
    }

    int methodCount = metaObject->methodCount();
    for (int ii = methodCount - 1; ii >= 3; --ii) { // >=3 to block the destroyed signal and deleteLater() slot
        QMetaMethod m = metaObject->method(ii);
        if (m.access() == QMetaMethod::Private)
            continue;
        QString methodName = QString::fromUtf8(m.signature());

        int parenIdx = methodName.indexOf(QLatin1Char('('));
        Q_ASSERT(parenIdx != -1);
        QStringRef methodNameRef = methodName.leftRef(parenIdx);

        if (methodNameRef == property) {
            rv.load(m);
            return rv;
        }
    }

    return rv;
}

isAllowedInRevision()

bool QDeclarativePropertyCache::isAllowedInRevision ( Data *  data ) const

inline

Definition at line 227 of file qdeclarativepropertycache_p.h.

Referenced by QDeclarativeEnginePrivate::createCache(), QDeclarativeCompiler::indexOfProperty(), QDeclarativeCompiler::indexOfSignal(), and QDeclarativeObjectScriptClass::queryProperty().

{
    return (data->metaObjectOffset == -1 && data->revision == 0) ||
           (allowedRevisionCache[data->metaObjectOffset] >= data->revision);
}

method()

QDeclarativePropertyCache::Data * QDeclarativePropertyCache::method

(

int

index

)

const

Definition at line 365 of file qdeclarativepropertycache.cpp.

Referenced by flush_vme_signal(), and QDeclarativeObjectMethodScriptClass::relatedMethod().

{
    if (index < 0 || index >= methodIndexCache.count())
        return 0;

    return methodIndexCache.at(index);
}

overrideData()

QDeclarativePropertyCache::Data * QDeclarativePropertyCache::overrideData ( Data *  data ) const

inline

Definition at line 198 of file qdeclarativepropertycache_p.h.

Referenced by QDeclarativeCompiler::indexOfProperty(), and QDeclarativeCompiler::indexOfSignal().

{
    if (data->overrideIndex < 0)
        return 0;

    if (data->overrideIndexIsProperty)
        return indexCache.at(data->overrideIndex);
    else
        return methodIndexCache.at(data->overrideIndex);
}

property() [1/5]

QDeclarativePropertyCache::Data * QDeclarativePropertyCache::property ( const QScriptDeclarativeClass::Identifier &  id ) const

inline

Definition at line 210 of file qdeclarativepropertycache_p.h.

Referenced by QDeclarativePropertyPrivate::binding(), QDeclarativeCompiler::buildProperty(), QDeclarativeContext::contextProperty(), QDeclarativePropertyPrivate::findAliasTarget(), QDeclarativeCompiledBindingsPrivate::findproperty(), QDeclarativeCompiler::genObject(), QDeclarativeCompiler::indexOfProperty(), QDeclarativeCompiler::indexOfSignal(), QDeclarativePropertyPrivate::initProperty(), property(), QDeclarativeListReference::QDeclarativeListReference(), QDeclarativeObjectScriptClass::queryProperty(), QDeclarativePropertyPrivate::setBinding(), QDeclarativePropertyPrivate::setBindingNoEnable(), QDeclarativeEngineDebugService::setMethodBody(), and QDeclarativeVisualDataModel::stringValue().

{
    return identifierCache.value(id);
}

property() [2/5]

QDeclarativePropertyCache::Data * QDeclarativePropertyCache::property

(

const QString &

str

)

const

Definition at line 374 of file qdeclarativepropertycache.cpp.

{
    return stringCache.value(str);
}

property() [3/5]

QDeclarativePropertyCache::Data * QDeclarativePropertyCache::property

(

int

index

)

const

Definition at line 356 of file qdeclarativepropertycache.cpp.

{
    if (index < 0 || index >= indexCache.count())
        return 0;

    return indexCache.at(index);
}

property() [4/5]

QDeclarativePropertyCache::Data * QDeclarativePropertyCache::property ( QDeclarativeEngine *  engine, QObject *  obj, const QScriptDeclarativeClass::Identifier &  name, Data &  local  )

static

Definition at line 411 of file qdeclarativepropertycache.cpp.

{
    QDeclarativePropertyCache::Data *rv = 0;

    QDeclarativeEnginePrivate *enginePrivate = QDeclarativeEnginePrivate::get(engine);

    QDeclarativePropertyCache *cache = 0;
    QDeclarativeData *ddata = QDeclarativeData::get(obj);
    if (ddata && ddata->propertyCache && ddata->propertyCache->qmlEngine() == engine)
        cache = ddata->propertyCache;
    if (!cache) {
        cache = enginePrivate->cache(obj);
        if (cache && ddata && !ddata->propertyCache) { cache->addref(); ddata->propertyCache = cache; }
    }

    if (cache) {
        rv = cache->property(name);
    } else {
        local = QDeclarativePropertyCache::create(obj->metaObject(), enginePrivate->objectClass->toString(name));
        if (local.isValid())
            rv = &local;
    }

    return rv;
}

property() [5/5]

QDeclarativePropertyCache::Data * QDeclarativePropertyCache::property ( QDeclarativeEngine *  engine, QObject *  obj, const QString &  name, Data &  local  )

static

Definition at line 438 of file qdeclarativepropertycache.cpp.

{
    QDeclarativePropertyCache::Data *rv = 0;

    if (!engine) {
        local = QDeclarativePropertyCache::create(obj->metaObject(), name);
        if (local.isValid())
            rv = &local;
    } else {
        QDeclarativeEnginePrivate *enginePrivate = QDeclarativeEnginePrivate::get(engine);

        QDeclarativePropertyCache *cache = 0;
        QDeclarativeData *ddata = QDeclarativeData::get(obj);
        if (ddata && ddata->propertyCache && ddata->propertyCache->qmlEngine() == engine)
            cache = ddata->propertyCache;
        if (!cache) {
            cache = enginePrivate->cache(obj);
            if (cache && ddata && !ddata->propertyCache) { cache->addref(); ddata->propertyCache = cache; }
        }

        if (cache) {
            rv = cache->property(name);
        } else {
            local = QDeclarativePropertyCache::create(obj->metaObject(), name);
            if (local.isValid())
                rv = &local;
        }
    }

    return rv;
}

propertyNames()

QStringList QDeclarativePropertyCache::propertyNames

(

)

const

Definition at line 406 of file qdeclarativepropertycache.cpp.

Referenced by QDeclarativeObjectScriptClass::propertyNames().

{
    return stringCache.keys();
}

qmlEngine()

QDeclarativeEngine * QDeclarativePropertyCache::qmlEngine ( ) const

inline

Definition at line 233 of file qdeclarativepropertycache_p.h.

Referenced by property().

{
    return engine;
}

update()

void QDeclarativePropertyCache::update	(	QDeclarativeEngine *	engine,
		const QMetaObject *	metaObject
	)

Definition at line 341 of file qdeclarativepropertycache.cpp.

Referenced by QDeclarativeOpenMetaObjectType::createProperty(), and QDeclarativePropertyCache().

{
    Q_ASSERT(engine);
    Q_ASSERT(metaObject);

    clear();

    // Optimization to prevent unnecessary reallocation of lists
    indexCache.reserve(metaObject->propertyCount());
    methodIndexCache.reserve(metaObject->methodCount());

    updateRecur(engine,metaObject);
}

updateRecur()

void QDeclarativePropertyCache::updateRecur ( QDeclarativeEngine *  engine, const QMetaObject *  metaObject  )

private

Definition at line 331 of file qdeclarativepropertycache.cpp.

Referenced by update().

{
    if (!metaObject)
        return;

    updateRecur(engine, metaObject->superClass());

    append(engine, metaObject);
}

Friends and Related Functions

QDeclarativeEnginePrivate

friend class QDeclarativeEnginePrivate

friend

Definition at line 160 of file qdeclarativepropertycache_p.h.

Properties

allowedRevisionCache

AllowedRevisionCache QDeclarativePropertyCache::allowedRevisionCache

private

Definition at line 178 of file qdeclarativepropertycache_p.h.

Referenced by append(), copy(), QDeclarativeEnginePrivate::createCache(), and isAllowedInRevision().

engine

QDeclarativeEngine* QDeclarativePropertyCache::engine

private

Definition at line 173 of file qdeclarativepropertycache_p.h.

Referenced by copy(), property(), QDeclarativePropertyCache(), and qmlEngine().

identifierCache

IdentifierCache QDeclarativePropertyCache::identifierCache

private

Definition at line 177 of file qdeclarativepropertycache_p.h.

Referenced by append(), clear(), copy(), and property().

indexCache

IndexCache QDeclarativePropertyCache::indexCache

private

Definition at line 174 of file qdeclarativepropertycache_p.h.

Referenced by append(), clear(), copy(), overrideData(), property(), and update().

methodIndexCache

IndexCache QDeclarativePropertyCache::methodIndexCache

private

Definition at line 175 of file qdeclarativepropertycache_p.h.

Referenced by append(), clear(), copy(), method(), overrideData(), and update().

stringCache

StringCache QDeclarativePropertyCache::stringCache

private

Definition at line 176 of file qdeclarativepropertycache_p.h.

Referenced by append(), clear(), copy(), QDeclarativeEnginePrivate::createCache(), property(), and propertyNames().

---

The documentation for this class was generated from the following files:

• /src/declarative/qml/qdeclarativepropertycache_p.h
• /src/declarative/qml/qdeclarativepropertycache.cpp