From f1987763b81d4a73063ebbd494dd3d09fef6383d Mon Sep 17 00:00:00 2001
From: Marcelo Lira <marcelo.lira@openbossa.org>
Date: Thu, 30 Sep 2010 10:50:04 -0300
Subject: Private enums are now accepted in the type system database.

This is done to allow enum value evaluation.
Comes together with a nice test.
---
 abstractmetabuilder.cpp | 19 +++++++++++--------
 tests/testenum.cpp      | 43 +++++++++++++++++++++++++++++++++++++++++++
 tests/testenum.h        |  1 +
 3 files changed, 55 insertions(+), 8 deletions(-)

diff --git a/abstractmetabuilder.cpp b/abstractmetabuilder.cpp
index 50a0e6576..47c8e4843 100644
--- a/abstractmetabuilder.cpp
+++ b/abstractmetabuilder.cpp
@@ -894,14 +894,18 @@ void AbstractMetaBuilder::figureOutDefaultEnumArguments()
 
 AbstractMetaEnum* AbstractMetaBuilder::traverseEnum(EnumModelItem enumItem, AbstractMetaClass* enclosing, const QSet<QString> &enumsDeclarations)
 {
-    // Skipping private enums.
-    if (enumItem->accessPolicy() == CodeModel::Private)
-        return 0;
-
     QString qualifiedName = enumItem->qualifiedName().join("::");
 
     TypeEntry* typeEntry = 0;
-    if (!enumItem->isAnonymous()) {
+    if (enumItem->accessPolicy() == CodeModel::Private) {
+        QStringList names = enumItem->qualifiedName();
+        QString enumName = names.last();
+        QString nspace;
+        if (names.size() > 1)
+            nspace = QStringList(names.mid(0, names.size() - 1)).join("::");
+        typeEntry = new EnumTypeEntry(nspace, enumName, 0);
+        TypeDatabase::instance()->addType(typeEntry);
+    } else if (!enumItem->isAnonymous()) {
         typeEntry = TypeDatabase::instance()->findType(qualifiedName);
     } else {
         QStringList tmpQualifiedName = enumItem->qualifiedName();
@@ -950,7 +954,7 @@ AbstractMetaEnum* AbstractMetaBuilder::traverseEnum(EnumModelItem enumItem, Abst
     switch (enumItem->accessPolicy()) {
     case CodeModel::Public: *metaEnum += AbstractMetaAttributes::Public; break;
     case CodeModel::Protected: *metaEnum += AbstractMetaAttributes::Protected; break;
-//     case CodeModel::Private: *meta_enum += AbstractMetaAttributes::Private; break;
+    case CodeModel::Private: *metaEnum += AbstractMetaAttributes::Private; break;
     default: break;
     }
 
@@ -983,7 +987,6 @@ AbstractMetaEnum* AbstractMetaBuilder::traverseEnum(EnumModelItem enumItem, Abst
     metaEnum->setOriginalAttributes(metaEnum->attributes());
 
     // Register all enum values on Type database
-    TypeDatabase* typeDb = TypeDatabase::instance();
     foreach(EnumeratorModelItem e, enumItem->enumerators()) {
         QString name;
         if (enclosing) {
@@ -992,7 +995,7 @@ AbstractMetaEnum* AbstractMetaBuilder::traverseEnum(EnumModelItem enumItem, Abst
         }
         name += e->name();
         EnumValueTypeEntry* enumValue = new EnumValueTypeEntry(name, e->value(), static_cast<EnumTypeEntry*>(typeEntry), typeEntry->version());
-        typeDb->addType(enumValue);
+        TypeDatabase::instance()->addType(enumValue);
     }
 
     return metaEnum;
diff --git a/tests/testenum.cpp b/tests/testenum.cpp
index 17636badd..698efa8d6 100644
--- a/tests/testenum.cpp
+++ b/tests/testenum.cpp
@@ -255,6 +255,49 @@ void TestEnum::testEnumValueFromNeighbourEnum()
     QCOMPARE(enumValueB1->stringValue(), QString("ValueA0"));
 }
 
+void TestEnum::testPrivateEnum()
+{
+    const char* cppCode ="\
+    class A {\
+    private:\
+        enum PrivateEnum { Priv0 = 0x0f, Priv1 = 0xf0 };\
+    public:\
+        enum PublicEnum { Pub0 = Priv0, Pub1 = A::Priv1 };\
+    };\
+    ";
+    const char* xmlCode = "\
+    <typesystem package=\"Foo\"> \
+        <value-type name='A'> \
+            <enum-type name='PublicEnum'/>\
+        </value-type> \
+    </typesystem>";
+
+    TestUtil t(cppCode, xmlCode, false);
+
+    AbstractMetaClass* classA = t.builder()->classes().findClass("A");
+    QVERIFY(classA);
+    QCOMPARE(classA->enums().count(), 2);
+
+    AbstractMetaEnum* privateEnum = classA->findEnum("PrivateEnum");
+    QVERIFY(privateEnum);
+    QVERIFY(privateEnum->isPrivate());
+    QCOMPARE(privateEnum->typeEntry()->qualifiedCppName(), QString("A::PrivateEnum"));
+
+    AbstractMetaEnum* publicEnum = classA->findEnum("PublicEnum");
+    QVERIFY(publicEnum);
+    QCOMPARE(publicEnum->typeEntry()->qualifiedCppName(), QString("A::PublicEnum"));
+
+    AbstractMetaEnumValue* pub0 = publicEnum->values().first();
+    QCOMPARE(pub0->name(), QString("Pub0"));
+    QCOMPARE(pub0->value(), 0x0f);
+    QCOMPARE(pub0->stringValue(), QString("Priv0"));
+
+    AbstractMetaEnumValue* pub1 = publicEnum->values().last();
+    QCOMPARE(pub1->name(), QString("Pub1"));
+    QCOMPARE(pub1->value(), 0xf0);
+    QCOMPARE(pub1->stringValue(), QString("A::Priv1"));
+}
+
 QTEST_APPLESS_MAIN(TestEnum)
 
 #include "testenum.moc"
diff --git a/tests/testenum.h b/tests/testenum.h
index 762aed609..e4aaa1368 100644
--- a/tests/testenum.h
+++ b/tests/testenum.h
@@ -34,6 +34,7 @@ private slots:
     void testAnonymousEnum();
     void testGlobalEnums();
     void testEnumValueFromNeighbourEnum();
+    void testPrivateEnum();
 };
 
 #endif
-- 
cgit v1.2.3