Remove "All rights reserved" line from license headers.

[profile/ivi/qtdeclarative.git] / src / declarative / qml / qdeclarativetypenamecache_p.h

diff --git a/src/declarative/qml/qdeclarativetypenamecache_p.h b/src/declarative/qml/qdeclarativetypenamecache_p.h
index abf18ce..9cf52f9 100644 (file)
--- a/src/declarative/qml/qdeclarativetypenamecache_p.h
+++ b/src/declarative/qml/qdeclarativetypenamecache_p.h
@@ -1,8 +1,7 @@
 /****************************************************************************
 **
-** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
-** All rights reserved.
-** Contact: Nokia Corporation (qt-info@nokia.com)
+** Copyright (C) 2012 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: http://www.qt-project.org/
 **
 ** This file is part of the QtDeclarative module of the Qt Toolkit.
 **
@@ -35,6 +34,7 @@
 **
 **
 **
+**
 ** $QT_END_LICENSE$
 **
 ****************************************************************************/
@@ -53,96 +53,132 @@
 // We mean it.
 //
 
-#include "private/qdeclarativerefcount_p.h"
-#include "private/qdeclarativecleanup_p.h"
-#include "private/qdeclarativemetatype_p.h"
-
-#include <private/qscriptdeclarativeclass_p.h>
+#include <private/qdeclarativerefcount_p.h>
+#include "qdeclarativecleanup_p.h"
+#include "qdeclarativemetatype_p.h"
 
 #include <private/qhashedstring_p.h>
 
+#include <QtCore/qvector.h>
+
 QT_BEGIN_NAMESPACE
 
 class QDeclarativeType;
 class QDeclarativeEngine;
-class QDeclarativeTypeNameCache : public QDeclarativeRefCount, public QDeclarativeCleanup
+class QDeclarativeTypeNameCache : public QDeclarativeRefCount
 {
 public:
-    QDeclarativeTypeNameCache(QDeclarativeEngine *);
+    QDeclarativeTypeNameCache();
     virtual ~QDeclarativeTypeNameCache();
 
-    struct Data {
-        inline Data();
-        inline Data(const Data &);
-        inline ~Data();
-        inline Data &operator=(const Data &);
-        QDeclarativeType *type;
-        QDeclarativeTypeNameCache *typeNamespace;
-        int importedScriptIndex;
-    };
+    inline bool isEmpty() const;
 
-    void add(const QString &, int);
-    void add(const QString &, QDeclarativeType *);
-    void add(const QString &, QDeclarativeTypeNameCache *);
+    void add(const QHashedString &name, int sciptIndex = -1, const QHashedString &nameSpace = QHashedString());
 
-    Data *data(const QString &) const;
-    inline Data *data(const QHashedV8String &) const;
-    inline bool isEmpty() const;
+    struct Result {
+        inline Result();
+        inline Result(const void *importNamespace);
+        inline Result(QDeclarativeType *type);
+        inline Result(int scriptIndex);
+        inline Result(const Result &);
 
-    inline QDeclarativeMetaType::ModuleApiInstance *moduleApi() const;
-    void setModuleApi(QDeclarativeMetaType::ModuleApiInstance *);
+        inline bool isValid() const;
 
-protected:
-    virtual void clear();
+        QDeclarativeType *type;
+        const void *importNamespace;
+        int scriptIndex;
+    };
+    Result query(const QHashedStringRef &);
+    Result query(const QHashedStringRef &, const void *importNamespace);
+    Result query(const QHashedV8String &);
+    Result query(const QHashedV8String &, const void *importNamespace);
+    QDeclarativeMetaType::ModuleApiInstance *moduleApi(const void *importNamespace);
 
 private:
-    typedef QStringHash<Data> StringCache;
+    friend class QDeclarativeImports;
 
-    StringCache stringCache;
+    struct Import {
+        inline Import();
+        // Imported module
+        QDeclarativeMetaType::ModuleApiInstance *moduleApi;
+        QVector<QDeclarativeTypeModuleVersion> modules;
+
+        // Or, imported script
+        int scriptIndex;
+    };
+
+    template<typename Key>
+    Result query(const QStringHash<Import> &imports, Key key)
+    {
+        Import *i = imports.value(key);
+        if (i) {
+            if (i->scriptIndex != -1) {
+                return Result(i->scriptIndex);
+            } else {
+                return Result(static_cast<const void *>(i));
+            }
+        }
+
+        return Result();
+    }
+
+    template<typename Key>
+    Result typeSearch(const QVector<QDeclarativeTypeModuleVersion> &modules, Key key)
+    {
+        QVector<QDeclarativeTypeModuleVersion>::const_iterator end = modules.constEnd();
+        for (QVector<QDeclarativeTypeModuleVersion>::const_iterator it = modules.constBegin(); it != end; ++it) {
+            if (QDeclarativeType *type = it->type(key))
+                return Result(type);
+        }
+
+        return Result();
+    }
+
+    QStringHash<Import> m_namedImports;
+    QMap<const Import *, QStringHash<Import> > m_namespacedImports;
+    QVector<QDeclarativeTypeModuleVersion> m_anonymousImports;
 
     QDeclarativeEngine *engine;
-    QDeclarativeMetaType::ModuleApiInstance *m_moduleApi;
 };
 
-QDeclarativeTypeNameCache::Data::Data()
-: type(0), typeNamespace(0), importedScriptIndex(-1)
+QDeclarativeTypeNameCache::Result::Result()
+: type(0), importNamespace(0), scriptIndex(-1)
 {
 }
 
-QDeclarativeTypeNameCache::Data::~Data()
+QDeclarativeTypeNameCache::Result::Result(const void *importNamespace)
+: type(0), importNamespace(importNamespace), scriptIndex(-1)
 {
-    if (typeNamespace) typeNamespace->release();
 }
 
-bool QDeclarativeTypeNameCache::isEmpty() const
+QDeclarativeTypeNameCache::Result::Result(QDeclarativeType *type)
+: type(type), importNamespace(0), scriptIndex(-1)
 {
-    return stringCache.isEmpty();
 }
 
-QDeclarativeTypeNameCache::Data::Data(const QDeclarativeTypeNameCache::Data &o)
-: type(o.type), typeNamespace(o.typeNamespace), importedScriptIndex(o.importedScriptIndex)
+QDeclarativeTypeNameCache::Result::Result(int scriptIndex)
+: type(0), importNamespace(0), scriptIndex(scriptIndex)
 {
-    if (typeNamespace) typeNamespace->addref();
 }
 
-QDeclarativeTypeNameCache::Data &QDeclarativeTypeNameCache::Data::operator=(const QDeclarativeTypeNameCache::Data &o)
+QDeclarativeTypeNameCache::Result::Result(const Result &o)
+: type(o.type), importNamespace(o.importNamespace), scriptIndex(o.scriptIndex)
 {
-    if (o.typeNamespace) o.typeNamespace->addref();
-    if (typeNamespace) typeNamespace->release();
-    type = o.type;
-    typeNamespace = o.typeNamespace;
-    importedScriptIndex = o.importedScriptIndex;
-    return *this;
 }
 
-QDeclarativeMetaType::ModuleApiInstance *QDeclarativeTypeNameCache::moduleApi() const
+bool QDeclarativeTypeNameCache::Result::isValid() const
 {
-    return m_moduleApi;
+    return type || importNamespace || scriptIndex != -1;
 }
 
-QDeclarativeTypeNameCache::Data *QDeclarativeTypeNameCache::data(const QHashedV8String &name) const
+QDeclarativeTypeNameCache::Import::Import()
+: moduleApi(0), scriptIndex(-1)
+{
+}
+
+bool QDeclarativeTypeNameCache::isEmpty() const
 {
-    return stringCache.value(name);
+    return m_namedImports.isEmpty() && m_anonymousImports.isEmpty();
 }
 
 QT_END_NAMESPACE