Code model: Change some QHash instances to QList

The usage of QHash causes the order of the members to
be non-deterministic and makes it hard to compare
the generated code. Use QList instead where it is easily
possible.

Task-number: PYSIDE-323
Change-Id: I7fc139c382b254cfc73c8d770c0a4a69dc220607
Reviewed-by: Alexandru Croitor <alexandru.croitor@qt.io>

4 files changed, 86 insertions, 83 deletions

diff --git a/ApiExtractor/abstractmetabuilder.cpp b/ApiExtractor/abstractmetabuilder.cpp
index 2ac1f2e12..b6bce7d90 100644
--- a/ApiExtractor/abstractmetabuilder.cpp
+++ b/ApiExtractor/abstractmetabuilder.cpp
@@ -421,8 +421,6 @@ void AbstractMetaBuilderPrivate::fixQObjectForScope(const FileModelItem &dom,
                                                     const TypeDatabase *types,
                                                     const NamespaceModelItem &scope)
 {
-    typedef QHash<QString, NamespaceModelItem> NamespaceModelItemMap;
-
     foreach (const ClassModelItem &item, scope->classes()) {
         QString qualifiedName = item->qualifiedName().join(colonColon());
         TypeEntry* entry = types->findType(qualifiedName);
@@ -432,10 +430,10 @@ void AbstractMetaBuilderPrivate::fixQObjectForScope(const FileModelItem &dom,
         }
     }
 
-    const NamespaceModelItemMap namespaceMap = scope->namespaceMap();
-    for (NamespaceModelItemMap::const_iterator it = namespaceMap.cbegin(), end = namespaceMap.cend(); it != end; ++it) {
-        if (scope != it.value())
-            fixQObjectForScope(dom, types, it.value());
+    const NamespaceList &namespaces = scope->namespaces();
+    foreach (const NamespaceModelItem &n, namespaces) {
+        if (scope != n)
+            fixQObjectForScope(dom, types, n);
     }
 }
 
@@ -494,7 +492,7 @@ void AbstractMetaBuilderPrivate::traverseDom(const FileModelItem &dom)
     }
 
     // We need to know all global enums
-    ReportHandler::setProgressReference(dom->enumMap());
+    ReportHandler::setProgressReference(dom->enums());
     foreach (const EnumModelItem &item, dom->enums()) {
         ReportHandler::progress(QLatin1String("Generating enum model..."));
         AbstractMetaEnum *metaEnum = traverseEnum(item, 0, QSet<QString>());
@@ -504,13 +502,12 @@ void AbstractMetaBuilderPrivate::traverseDom(const FileModelItem &dom)
         }
     }
 
-    QHash<QString, NamespaceModelItem> namespaceMap = dom->namespaceMap();
-    NamespaceList namespaceTypeValues = namespaceMap.values();
+    NamespaceList namespaceTypeValues = dom->namespaces();
     qSort(namespaceTypeValues);
     NamespaceList::iterator nsit = std::unique(namespaceTypeValues.begin(), namespaceTypeValues.end());
     namespaceTypeValues.erase(nsit, namespaceTypeValues.end());
 
-    ReportHandler::setProgressReference(namespaceMap);
+    ReportHandler::setProgressReference(namespaceTypeValues);
     foreach (NamespaceModelItem item, namespaceTypeValues) {
         ReportHandler::progress(QLatin1String("Generating namespace model..."));
         AbstractMetaClass *metaClass = traverseNamespace(dom, item);
@@ -821,7 +818,7 @@ AbstractMetaClass *AbstractMetaBuilderPrivate::traverseNamespace(const FileModel
     }
 
     // Traverse namespaces recursively
-    NamespaceList innerNamespaces = namespaceItem->namespaceMap().values();
+    NamespaceList innerNamespaces = namespaceItem->namespaces();
     qSort(innerNamespaces);
     NamespaceList::iterator it = std::unique(innerNamespaces.begin(), innerNamespaces.end());
     innerNamespaces.erase(it, innerNamespaces.end());
@@ -1379,7 +1376,7 @@ void AbstractMetaBuilderPrivate::traverseNamespaceMembers(NamespaceModelItem ite
     traverseScopeMembers(item, metaClass);
 
     // Inner namespaces
-    NamespaceList innerNamespaces = item->namespaceMap().values();
+    NamespaceList innerNamespaces = item->namespaces();
     qSort(innerNamespaces);
     NamespaceList::iterator it = std::unique(innerNamespaces.begin(), innerNamespaces.end());
     innerNamespaces.erase(it, innerNamespaces.end());
@@ -2629,7 +2626,7 @@ bool AbstractMetaBuilderPrivate::isQObject(const FileModelItem &dom, const QStri
         QStringList names = qualifiedName.split(colonColon());
         NamespaceModelItem ns = dom;
         for (int i = 0; i < names.size() - 1 && ns; ++i)
-            ns = ns->namespaceMap().value(names.at(i));
+            ns = ns->findNamespace(names.at(i));
         if (ns && names.size() >= 2)
             classItem = ns->findClass(names.at(names.size() - 1));
     }
diff --git a/ApiExtractor/asttoxml.cpp b/ApiExtractor/asttoxml.cpp
index bae459659..170a12c12 100644
--- a/ApiExtractor/asttoxml.cpp
+++ b/ApiExtractor/asttoxml.cpp
@@ -73,9 +73,9 @@ void astToXML(QString name)
 
     s.writeStartElement(QLatin1String("code"));
 
-    const NamespaceModelItemMap &namespaceMap = dom->namespaceMap();
-    for (NamespaceModelItemMap::const_iterator it = namespaceMap.cbegin(), end = namespaceMap.cend(); it != end; ++it)
-        writeOutNamespace(s, it.value());
+    const NamespaceList &namespaces = dom->namespaces();
+    foreach (const NamespaceModelItem &n, namespaces)
+        writeOutNamespace(s, n);
 
     const ClassModelItemMap &typeMap = dom->classMap();
     for (ClassModelItemMap::const_iterator it = typeMap.cbegin(), end = typeMap.cend(); it != end; ++it)
@@ -89,17 +89,17 @@ void writeOutNamespace(QXmlStreamWriter &s, const NamespaceModelItem &item)
     s.writeStartElement(QLatin1String("namespace"));
     s.writeAttribute(QLatin1String("name"), item->name());
 
-    const NamespaceModelItemMap &namespaceMap = item->namespaceMap();
-    for (NamespaceModelItemMap::const_iterator it = namespaceMap.cbegin(), end = namespaceMap.cend(); it != end; ++it)
-        writeOutNamespace(s, it.value());
+    const NamespaceList &namespaces = item->namespaces();
+    foreach (const NamespaceModelItem &n, namespaces)
+        writeOutNamespace(s, n);
 
     const ClassModelItemMap &typeMap = item->classMap();
     for (ClassModelItemMap::const_iterator it = typeMap.cbegin(), end = typeMap.cend(); it != end; ++it)
         writeOutClass(s, it.value());
 
-    const EnumMap &enumMap = item->enumMap();
-    for (EnumMap::const_iterator it = enumMap.cbegin(), end = enumMap.cend(); it != end; ++it)
-        writeOutEnum(s, it.value());
+    const EnumList &enums = item->enums();
+    foreach (const EnumModelItem &e, enums)
+        writeOutEnum(s, e);
 
     s.writeEndElement();
 }
@@ -143,9 +143,9 @@ void writeOutClass(QXmlStreamWriter &s, const ClassModelItem &item)
     s.writeStartElement(QLatin1String("class"));
     s.writeAttribute(QLatin1String("name"), qualifiedName);
 
-    const EnumMap &enumMap = item->enumMap();
-    for (EnumMap::const_iterator it = enumMap.cbegin(), end = enumMap.cend(); it != end; ++it)
-        writeOutEnum(s, it.value());
+    const EnumList &enums = item->enums();
+    foreach (const EnumModelItem &e, enums)
+        writeOutEnum(s, e);
 
     const FunctionModelItemMap &functionMap = item->functionMap();
     for (FunctionModelItemMap::const_iterator it = functionMap.cbegin(), end = functionMap.cend(); it != end; ++it)
diff --git a/ApiExtractor/parser/codemodel.cpp b/ApiExtractor/parser/codemodel.cpp
index dd5a6d0bd..0a75f983c 100644
--- a/ApiExtractor/parser/codemodel.cpp
+++ b/ApiExtractor/parser/codemodel.cpp
@@ -30,22 +30,37 @@
 
 #include "codemodel.h"
 #include <algorithm>
+#include <functional>
 #include <iostream>
 #include <QDebug>
 
-// ---------------------------------------------------------------------------
+// Predicate to find an item by name in a list of QSharedPointer<Item>
+template <class T> class ModelItemNamePredicate : public std::unary_function<bool, QSharedPointer<T> >
+{
+public:
+    explicit ModelItemNamePredicate(const QString &name) : m_name(name) {}
+    bool operator()(const QSharedPointer<T> &item) const { return item->name() == m_name; }
 
-CodeModel::CodeModel() : m_globalNamespace(new _NamespaceModelItem(this))
+private:
+    const QString m_name;
+};
+
+template <class T>
+static QSharedPointer<T> findModelItem(const QList<QSharedPointer<T> > &list, const QString &name)
 {
+    typedef typename QList<QSharedPointer<T> >::const_iterator It;
+    const It it = std::find_if(list.begin(), list.end(), ModelItemNamePredicate<T>(name));
+    return it != list.end() ? *it : QSharedPointer<T>();
 }
 
-CodeModel::~CodeModel()
+// ---------------------------------------------------------------------------
+
+CodeModel::CodeModel() : m_globalNamespace(new _NamespaceModelItem(this))
 {
 }
 
-FileList CodeModel::files() const
+CodeModel::~CodeModel()
 {
-    return m_files.values();
 }
 
 NamespaceModelItem CodeModel::globalNamespace() const
@@ -55,12 +70,12 @@ NamespaceModelItem CodeModel::globalNamespace() const
 
 void CodeModel::addFile(FileModelItem item)
 {
-    m_files.insert(item->name(), item);
+    m_files.append(item);
 }
 
 FileModelItem CodeModel::findFile(const QString &name) const
 {
-    return m_files.value(name);
+    return findModelItem(m_files, name);
 }
 
 CodeModelItem CodeModel::findItem(const QStringList &qualifiedName, CodeModelItem scope) const
@@ -356,6 +371,16 @@ void formatSequence(QDebug &d, It i1, It i2, const char *separator=", ")
     }
 }
 
+template <class It>
+static void formatPtrSequence(QDebug &d, It i1, It i2, const char *separator=", ")
+{
+    for (It i = i1; i != i2; ++i) {
+        if (i != i1)
+            d << separator;
+        d << i->data();
+    }
+}
+
 void _CodeModelItem::formatKind(QDebug &d, int k)
 {
     if ((k & Kind_Variable) == Kind_Variable)
@@ -518,16 +543,6 @@ ClassList _ScopeModelItem::classes() const
     return result;
 }
 
-TypeDefList _ScopeModelItem::typeDefs() const
-{
-    return m_typeDefs.values();
-}
-
-VariableList _ScopeModelItem::variables() const
-{
-    return m_variables.values();
-}
-
 FunctionList _ScopeModelItem::functions() const
 {
     return m_functions.values();
@@ -543,14 +558,6 @@ FunctionDefinitionList _ScopeModelItem::functionDefinitions() const
     return m_functionDefinitions.values();
 }
 
-EnumList _ScopeModelItem::enums() const
-{
-    EnumList result;
-    foreach (const QString& name, m_enumNames)
-        result.append(m_enums.value(name));
-    return result;
-}
-
 void _ScopeModelItem::addClass(ClassModelItem item)
 {
     QString name = item->name();
@@ -572,19 +579,17 @@ void _ScopeModelItem::addFunctionDefinition(FunctionDefinitionModelItem item)
 
 void _ScopeModelItem::addVariable(VariableModelItem item)
 {
-    m_variables.insert(item->name(), item);
+    m_variables.append(item);
 }
 
 void _ScopeModelItem::addTypeDef(TypeDefModelItem item)
 {
-    m_typeDefs.insert(item->name(), item);
+    m_typeDefs.append(item);
 }
 
 void _ScopeModelItem::addEnum(EnumModelItem item)
 {
-    m_enumNames.removeOne(item->name());
-    m_enums.insert(item->name(), item);
-    m_enumNames.append(item->name());
+    m_enums.append(item);
 }
 
 #ifndef QT_NO_DEBUG_STREAM
@@ -605,13 +610,24 @@ static void formatScopeHash(QDebug &d, const char *prefix, const Hash &h)
     }
 }
 
+template <class List>
+static void formatScopeList(QDebug &d, const char *prefix, const List &l)
+{
+    if (!l.isEmpty()) {
+        d << prefix << '[' << l.size() << "](";
+        formatPtrSequence(d, l.begin(), l.end());
+        d << ')';
+    }
+}
+
 void _ScopeModelItem::formatScopeItemsDebug(QDebug &d) const
 {
     formatScopeHash(d, ", classes=", m_classes);
-    formatScopeHash(d, ", enums=", m_enums);
-    formatScopeHash(d, ", aliases=", m_typeDefs);
+    formatScopeList(d, ", enums=", m_enums);
+    formatScopeList(d, ", aliases=", m_typeDefs);
     formatScopeHash(d, ", functionDefs=", m_functionDefinitions);
     formatScopeHash(d, ", functions=", m_functions);
+    formatScopeList(d, ", variables=", m_variables);
 }
 
 void  _ScopeModelItem::formatDebug(QDebug &d) const
@@ -628,17 +644,17 @@ ClassModelItem _ScopeModelItem::findClass(const QString &name) const
 
 VariableModelItem _ScopeModelItem::findVariable(const QString &name) const
 {
-    return m_variables.value(name);
+    return findModelItem(m_variables, name);
 }
 
 TypeDefModelItem _ScopeModelItem::findTypeDef(const QString &name) const
 {
-    return m_typeDefs.value(name);
+    return findModelItem(m_typeDefs, name);
 }
 
 EnumModelItem _ScopeModelItem::findEnum(const QString &name) const
 {
-    return m_enums.value(name);
+    return findModelItem(m_enums, name);
 }
 
 FunctionList _ScopeModelItem::findFunctions(const QString &name) const
@@ -656,18 +672,14 @@ _NamespaceModelItem::~_NamespaceModelItem()
 {
 }
 
-NamespaceList _NamespaceModelItem::namespaces() const
-{
-    return m_namespaces.values();
-}
 void _NamespaceModelItem::addNamespace(NamespaceModelItem item)
 {
-    m_namespaces.insert(item->name(), item);
+    m_namespaces.append(item);
 }
 
 NamespaceModelItem _NamespaceModelItem::findNamespace(const QString &name) const
 {
-    return m_namespaces.value(name);
+    return findModelItem(m_namespaces, name);
 }
 
 _FileModelItem::~_FileModelItem()
@@ -678,7 +690,7 @@ _FileModelItem::~_FileModelItem()
 void _NamespaceModelItem::formatDebug(QDebug &d) const
 {
     _ScopeModelItem::formatDebug(d);
-    formatScopeHash(d, ", namespaces=", m_namespaces);
+    formatScopeList(d, ", namespaces=", m_namespaces);
 }
 #endif // !QT_NO_DEBUG_STREAM
 
diff --git a/ApiExtractor/parser/codemodel.h b/ApiExtractor/parser/codemodel.h
index 15a001652..91878155a 100644
--- a/ApiExtractor/parser/codemodel.h
+++ b/ApiExtractor/parser/codemodel.h
@@ -69,7 +69,7 @@ public:
     CodeModel();
     virtual ~CodeModel();
 
-    FileList files() const;
+    FileList files() const { return m_files; }
     NamespaceModelItem globalNamespace() const;
 
     void addFile(FileModelItem item);
@@ -78,7 +78,7 @@ public:
     CodeModelItem findItem(const QStringList &qualifiedName, CodeModelItem scope) const;
 
 private:
-    QHash<QString, FileModelItem> m_files;
+    FileList m_files;
     NamespaceModelItem m_globalNamespace;
 
 private:
@@ -298,11 +298,11 @@ public:
     ~_ScopeModelItem();
 
     ClassList classes() const;
-    EnumList enums() const;
+    EnumList enums() const { return m_enums; }
     FunctionDefinitionList functionDefinitions() const;
     FunctionList functions() const;
-    TypeDefList typeDefs() const;
-    VariableList variables() const;
+    TypeDefList typeDefs() const { return m_typeDefs; }
+    VariableList variables() const { return m_variables; }
 
     void addClass(ClassModelItem item);
     void addEnum(EnumModelItem item);
@@ -322,9 +322,6 @@ public:
     QStringList enumsDeclarations() const { return m_enumsDeclarations; }
 
     inline QHash<QString, ClassModelItem> classMap() const { return m_classes; }
-    inline QHash<QString, EnumModelItem> enumMap() const { return m_enums; }
-    inline QHash<QString, TypeDefModelItem> typeDefMap() const { return m_typeDefs; }
-    inline QHash<QString, VariableModelItem> variableMap() const { return m_variables; }
     inline QMultiHash<QString, FunctionDefinitionModelItem> functionDefinitionMap() const { return m_functionDefinitions; }
     inline QMultiHash<QString, FunctionModelItem> functionMap() const { return m_functions; }
 
@@ -346,14 +343,13 @@ protected:
 
 private:
     QHash<QString, ClassModelItem> m_classes;
-    QHash<QString, EnumModelItem> m_enums;
-    QHash<QString, TypeDefModelItem> m_typeDefs;
-    QHash<QString, VariableModelItem> m_variables;
+    EnumList m_enums;
+    TypeDefList m_typeDefs;
+    VariableList m_variables;
     QMultiHash<QString, FunctionDefinitionModelItem> m_functionDefinitions;
     QMultiHash<QString, FunctionModelItem> m_functions;
 
 private:
-    QStringList m_enumNames;
     QStringList m_enumsDeclarations;
 };
 
@@ -407,20 +403,18 @@ public:
         : _ScopeModelItem(model, name, kind) {}
     ~_NamespaceModelItem();
 
-    NamespaceList namespaces() const;
+    NamespaceList namespaces() const { return m_namespaces; }
 
     void addNamespace(NamespaceModelItem item);
 
     NamespaceModelItem findNamespace(const QString &name) const;
 
-    inline QHash<QString, NamespaceModelItem> namespaceMap() const { return m_namespaces; };
-
 #ifndef QT_NO_DEBUG_STREAM
     void formatDebug(QDebug &d) const Q_DECL_OVERRIDE;
 #endif
 
 private:
-    QHash<QString, NamespaceModelItem> m_namespaces;
+    NamespaceList m_namespaces;
 };
 
 class _FileModelItem: public _NamespaceModelItem