[Backport generator] Remove figureOutEnumValues and company

The resulting enumValueRedirection was not used in the PythonQt generator.
Perhaps it was a remnant of the original Java wrapper generator.

(cherry picked from commit MeVisLab/pythonqt@4c61ee7)

Author: usiems

generator/abstractmetabuilder.cpp

@@ -602,7 +602,6 @@ bool AbstractMetaBuilder::build()
         }
     }
 
-    figureOutEnumValues();
     checkFunctionModifications();
 
     for (AbstractMetaClass *cls :  m_meta_classes) {
@@ -761,223 +760,6 @@ AbstractMetaClass *AbstractMetaBuilder::traverseNamespace(NamespaceModelItem nam
     return meta_class;
 }
 
-struct Operator
-{
-    enum Type { Plus, ShiftLeft, None };
-
-    Operator() : type(None) { }
-
-    int calculate(int x) {
-        switch (type) {
-        case Plus: return x + value;
-        case ShiftLeft: return x << value;
-        case None: return x;
-        }
-        return x;
-    }
-
-    Type type;
-    int value;
-};
-
-
-
-Operator findOperator(QString *s) {
-    const char *names[] = {
-        "+",
-        "<<"
-    };
-
-    for (int i=0; i<Operator::None; ++i) {
-        QString name = QLatin1String(names[i]);
-        QString str = *s;
-        int splitPoint = str.indexOf(name);
-        if (splitPoint > 0) {
-            bool ok;
-            QString right = str.mid(splitPoint + name.length());
-            Operator op;
-            op.value = right.toInt(&ok);
-            if (ok) {
-                op.type = Operator::Type(i);
-                *s = str.left(splitPoint).trimmed();
-                return op;
-            }
-        }
-    }
-    return Operator();
-}
-
-int AbstractMetaBuilder::figureOutEnumValue(const QString &stringValue,
-                                        int oldValuevalue,
-                                        AbstractMetaEnum *meta_enum,
-                                        AbstractMetaFunction *meta_function)
-{
-    Q_UNUSED(meta_function)
-    if (stringValue.isEmpty())
-        return oldValuevalue;
-
-    QStringList stringValues = stringValue.split("|");
-
-    int returnValue = 0;
-
-    bool matched = false;
-
-    for (int i=0; i<stringValues.size(); ++i) {
-        QString s = stringValues.at(i).trimmed();
-
-        bool ok;
-        int v;
-
-        Operator op = findOperator(&s);
-
-        if (s.length() > 0 && s.at(0) == QLatin1Char('0'))
-            v = s.toUInt(&ok, 0);
-        else
-            v = s.toInt(&ok);
-
-        if (ok) {
-            matched = true;
-
-        } else if (m_enum_values.contains(s)) {
-            v = m_enum_values[s]->value();
-            matched = true;
-
-        } else {
-            AbstractMetaEnumValue *ev = 0;
-
-            if (meta_enum && (ev = meta_enum->values().find(s))) {
-                v = ev->value();
-                matched = true;
-
-            } else if (meta_enum && (ev = meta_enum->enclosingClass()->findEnumValue(s, meta_enum))) {
-                v = ev->value();
-                matched = true;
-
-            } else {
-              /*
-                if (meta_enum)
-                    ReportHandler::warning("unhandled enum value: " + s + " in "
-                                           + meta_enum->enclosingClass()->name() + "::"
-                                           + meta_enum->name());
-                else
-                    ReportHandler::warning("unhandled enum value: Unknown enum");
-                    */
-            }
-        }
-
-        if (matched)
-            returnValue |= op.calculate(v);
-    }
-
-    if (!matched) {
-        /* not helpful...
-        QString warn = QString("unmatched enum %1").arg(stringValue);
-
-        if (meta_function != 0) {
-            warn += QString(" when parsing default value of '%1' in class '%2'")
-                .arg(meta_function->name())
-                .arg(meta_function->implementingClass()->name());
-        }
-
-        ReportHandler::warning(warn);
-        */
-        returnValue = oldValuevalue;
-    }
-
-    return returnValue;
-}
-
-void AbstractMetaBuilder::figureOutEnumValuesForClass(AbstractMetaClass *meta_class,
-                                                  QSet<AbstractMetaClass *> *classes)
-{
-    AbstractMetaClass *base = meta_class->baseClass();
-
-    if (base != 0 && !classes->contains(base))
-        figureOutEnumValuesForClass(base, classes);
-
-    if (classes->contains(meta_class))
-        return;
-
-    AbstractMetaEnumList enums = meta_class->enums();
-    for (AbstractMetaEnum *e :  enums) {
-        if (!e) {
-            ReportHandler::warning("bad enum in class " + meta_class->name());
-            continue;
-        }
-        AbstractMetaEnumValueList lst = e->values();
-        int value = 0;
-        for (int i=0; i<lst.size(); ++i) {
-            value = figureOutEnumValue(lst.at(i)->stringValue(), value, e);
-            lst.at(i)->setValue(value);
-            value++;
-        }
-
-        // Check for duplicate values...
-        EnumTypeEntry *ete = e->typeEntry();
-        if (!ete->forceInteger()) {
-            QHash<int, AbstractMetaEnumValue *> entries;
-            for (AbstractMetaEnumValue *v :  lst) {
-
-                bool vRejected = ete->isEnumValueRejected(v->name());
-
-                AbstractMetaEnumValue *current = entries.value(v->value());
-                if (current) {
-                    bool currentRejected = ete->isEnumValueRejected(current->name());
-                    if (!currentRejected && !vRejected) {
-                        /* Removed because I don't see the sense of rejecting duplicate values...
-                        ReportHandler::warning(
-                            QString("duplicate enum values: %1::%2, %3 and %4 are %5, already rejected: (%6)")
-                            .arg(meta_class->name())
-                            .arg(e->name())
-                            .arg(v->name())
-                            .arg(entries[v->value()]->name())
-                            .arg(v->value())
-                            .arg(ete->enumValueRejections().join(", ")));
-                        continue;
-                        */
-                    }
-                }
-
-                if (!vRejected)
-                    entries[v->value()] = v;
-            }
-
-            // Entries now contain all the original entries, no
-            // rejected ones... Use this to generate the enumValueRedirection table.
-            for (AbstractMetaEnumValue *reject :  lst) {
-                if (!ete->isEnumValueRejected(reject->name()))
-                    continue;
-
-                AbstractMetaEnumValue *used = entries.value(reject->value());
-                if (!used) {
-                    ReportHandler::warning(
-                        QString::fromLatin1("Rejected enum has no alternative...: %1::%2")
-                        .arg(meta_class->name())
-                        .arg(reject->name()));
-                    continue;
-                }
-                ete->addEnumValueRedirection(reject->name(), used->name());
-            }
-
-        }
-    }
-
-
-
-    *classes += meta_class;
-}
-
-
-void AbstractMetaBuilder::figureOutEnumValues()
-{
-    // Keep a set of classes that we already traversed. We use this to
-    // enforce that we traverse base classes prior to subclasses.
-    QSet<AbstractMetaClass *> classes;
-    for (AbstractMetaClass *c :  m_meta_classes) {
-        figureOutEnumValuesForClass(c, &classes);
-    }
-}
-
 
 AbstractMetaEnum *AbstractMetaBuilder::traverseEnum(EnumModelItem enum_item, AbstractMetaClass *enclosing, const QSet<QString> &enumsDeclarations)
 {

generator/abstractmetabuilder.h

@@ -84,10 +84,6 @@ class AbstractMetaBuilder
 
     void autoAddQEnumsForClassItem(ClassModelItem item);
 
-    void figureOutEnumValuesForClass(AbstractMetaClass *meta_class, QSet<AbstractMetaClass *> *classes);
-    int figureOutEnumValue(const QString &name, int value, AbstractMetaEnum *meta_enum, AbstractMetaFunction *meta_function = 0);
-    void figureOutEnumValues();
-
     void addAbstractMetaClass(AbstractMetaClass *cls);
     AbstractMetaClass *traverseTypeAlias(TypeAliasModelItem item);
     AbstractMetaClass *traverseClass(ClassModelItem item);

generator/typesystem.cpp

@@ -1742,19 +1742,6 @@ QString FlagsTypeEntry::jniName() const
     return "jint";
 }
 
-void EnumTypeEntry::addEnumValueRedirection(const QString &rejected, const QString &usedValue)
-{
-    m_enum_redirections << EnumValueRedirection(rejected, usedValue);
-}
-
-QString EnumTypeEntry::enumValueRedirection(const QString &value) const
-{
-    for (int i=0; i<m_enum_redirections.size(); ++i)
-        if (m_enum_redirections.at(i).rejected == value)
-            return m_enum_redirections.at(i).used;
-    return QString();
-}
-
 QString FlagsTypeEntry::qualifiedTargetLangName() const
 {
     return javaPackage() + "." + m_enum->javaQualifier() + "." + targetLangName();

generator/typesystem.h

@@ -727,9 +727,6 @@ class EnumTypeEntry : public TypeEntry
     void addEnumValueRejection(const QString &name) { m_rejected_enums << name; }
     QStringList enumValueRejections() const { return m_rejected_enums; }
 
-    void addEnumValueRedirection(const QString &rejected, const QString &usedValue);
-    QString enumValueRedirection(const QString &value) const;
-
     bool isEnumClass() const { return m_enum_class; }
     void setEnumClass(bool enum_class) { m_enum_class = enum_class; }
 
@@ -746,7 +743,6 @@ class EnumTypeEntry : public TypeEntry
     QString m_upper_bound;
 
     QStringList m_rejected_enums;
-    QList<EnumValueRedirection> m_enum_redirections;
 
     FlagsTypeEntry *m_flags;