From d3435da2648113d21fa85dc93b5b4f65a80f1731 Mon Sep 17 00:00:00 2001
From: Marcelo Lira <marcelo.lira@openbossa.org>
Date: Tue, 29 Jun 2010 17:19:44 -0300
Subject: Namespaces must be traversed recursively as they should.

---
 abstractmetabuilder.cpp | 72 ++++++++++++++++++++++++++++++++++++++-----------
 abstractmetabuilder.h   |  5 +++-
 2 files changed, 60 insertions(+), 17 deletions(-)

diff --git a/abstractmetabuilder.cpp b/abstractmetabuilder.cpp
index 41d49d00b..9b57e1e10 100644
--- a/abstractmetabuilder.cpp
+++ b/abstractmetabuilder.cpp
@@ -392,9 +392,9 @@ bool AbstractMetaBuilder::build(QIODevice* input)
     ReportHandler::flush();
 
     foreach (ClassModelItem item, typeValues)
-        traverseClassMembers(model_dynamic_cast<ScopeModelItem>(item));
-    foreach (NamespaceModelItem namespaceItem, namespaceMap.values())
-        traverseClassMembers(model_dynamic_cast<ScopeModelItem>(namespaceItem));
+        traverseClassMembers(item);
+    foreach (NamespaceModelItem item, namespaceTypeValues)
+        traverseNamespaceMembers(item);
 
     // Global functions
     foreach (FunctionModelItem func, m_dom->functions()) {
@@ -667,7 +667,10 @@ AbstractMetaClass* AbstractMetaBuilder::traverseNamespace(NamespaceModelItem nam
     }
 
     // Traverse namespaces recursively
-    QList<NamespaceModelItem> innerNamespaces = namespaceItem->namespaceMap().values();
+    NamespaceList innerNamespaces = namespaceItem->namespaceMap().values();
+    qSort(innerNamespaces);
+    NamespaceList::iterator it = std::unique(innerNamespaces.begin(), innerNamespaces.end());
+    innerNamespaces.erase(it, innerNamespaces.end());
     foreach (const NamespaceModelItem &ni, innerNamespaces) {
         AbstractMetaClass* mjc = traverseNamespace(ni);
         if (mjc) {
@@ -1115,9 +1118,24 @@ AbstractMetaClass* AbstractMetaBuilder::traverseClass(ClassModelItem classItem)
     return metaClass;
 }
 
-void AbstractMetaBuilder::traverseClassMembers(ScopeModelItem scopeItem)
+void AbstractMetaBuilder::traverseScopeMembers(ScopeModelItem item, AbstractMetaClass* metaClass)
 {
-    QString className = stripTemplateArgs(scopeItem->name());
+    // Classes/Namespace members
+    traverseFields(item, metaClass);
+    traverseFunctions(item, metaClass);
+
+    // Inner classes
+    ClassList innerClasses = item->classMap().values();
+    qSort(innerClasses);
+    ClassList::iterator it = std::unique(innerClasses.begin(), innerClasses.end());
+    innerClasses.erase(it, innerClasses.end());
+    foreach (const ClassModelItem& ci, innerClasses)
+        traverseClassMembers(ci);
+}
+
+AbstractMetaClass* AbstractMetaBuilder::currentTraversedClass(ScopeModelItem item)
+{
+    QString className = stripTemplateArgs(item->name());
     QString fullClassName = className;
 
     // This is an inner class
@@ -1125,23 +1143,45 @@ void AbstractMetaBuilder::traverseClassMembers(ScopeModelItem scopeItem)
         fullClassName = stripTemplateArgs(m_currentClass->typeEntry()->qualifiedCppName()) + "::" + fullClassName;
 
     AbstractMetaClass* metaClass = m_metaClasses.findClass(fullClassName);
+    if (!metaClass)
+        metaClass = m_templates.findClass(fullClassName);
+    return metaClass;
+}
+
+void AbstractMetaBuilder::traverseClassMembers(ClassModelItem item)
+{
+    AbstractMetaClass* metaClass = currentTraversedClass(model_dynamic_cast<ScopeModelItem>(item));
     if (!metaClass)
         return;
 
     AbstractMetaClass* oldCurrentClass = m_currentClass;
     m_currentClass = metaClass;
 
-    traverseFields(scopeItem, metaClass);
-    traverseFunctions(scopeItem, metaClass);
+    // Class members
+    traverseScopeMembers(model_dynamic_cast<ScopeModelItem>(item), metaClass);
 
-    {
-        ClassList innerClasses = scopeItem->classMap().values();
-        qSort(innerClasses);
-        ClassList::iterator it = std::unique(innerClasses.begin(), innerClasses.end());
-        innerClasses.erase(it, innerClasses.end());
-        foreach (const ClassModelItem& ci, innerClasses)
-            traverseClassMembers(model_dynamic_cast<ScopeModelItem>(ci));
-    }
+    m_currentClass = oldCurrentClass;
+}
+
+void AbstractMetaBuilder::traverseNamespaceMembers(NamespaceModelItem item)
+{
+    AbstractMetaClass* metaClass = currentTraversedClass(model_dynamic_cast<ScopeModelItem>(item));
+    if (!metaClass)
+        return;
+
+    AbstractMetaClass* oldCurrentClass = m_currentClass;
+    m_currentClass = metaClass;
+
+    // Namespace members
+    traverseScopeMembers(model_dynamic_cast<ScopeModelItem>(item), metaClass);
+
+    // Inner namespaces
+    NamespaceList innerNamespaces = item->namespaceMap().values();
+    qSort(innerNamespaces);
+    NamespaceList::iterator it = std::unique(innerNamespaces.begin(), innerNamespaces.end());
+    innerNamespaces.erase(it, innerNamespaces.end());
+    foreach (const NamespaceModelItem &ni, innerNamespaces)
+        traverseNamespaceMembers(ni);
 
     m_currentClass = oldCurrentClass;
 }
diff --git a/abstractmetabuilder.h b/abstractmetabuilder.h
index afcb07fbd..1bf252f92 100644
--- a/abstractmetabuilder.h
+++ b/abstractmetabuilder.h
@@ -100,7 +100,10 @@ public:
     void addAbstractMetaClass(AbstractMetaClass *cls);
     AbstractMetaClass *traverseTypeAlias(TypeAliasModelItem item);
     AbstractMetaClass *traverseClass(ClassModelItem item);
-    void traverseClassMembers(ScopeModelItem scopeItem);
+    AbstractMetaClass* currentTraversedClass(ScopeModelItem item);
+    void traverseScopeMembers(ScopeModelItem item, AbstractMetaClass* metaClass);
+    void traverseClassMembers(ClassModelItem scopeItem);
+    void traverseNamespaceMembers(NamespaceModelItem scopeItem);
     bool setupInheritance(AbstractMetaClass *metaClass);
     AbstractMetaClass *traverseNamespace(NamespaceModelItem item);
     AbstractMetaEnum *traverseEnum(EnumModelItem item, AbstractMetaClass *enclosing, const QSet<QString> &enumsDeclarations);
-- 
cgit v1.2.3