shiboken: Refactor code for querying functions of AbstractMetaClass

Move the checking code to a static method taking an AbstractMetaFunction
and add static methods operating on a list. This makes it possible
to implement checks without constructing temporary lists.

Change-Id: I9b137858f81396f8243f2d1be5277e6a38be4c84
Reviewed-by: Christian Tismer <tismer@stackless.com>

2 files changed, 81 insertions, 53 deletions

diff --git a/sources/shiboken2/ApiExtractor/abstractmetalang.cpp b/sources/shiboken2/ApiExtractor/abstractmetalang.cpp
index 6316cfc43..878d7fb9e 100644
--- a/sources/shiboken2/ApiExtractor/abstractmetalang.cpp
+++ b/sources/shiboken2/ApiExtractor/abstractmetalang.cpp
@@ -1826,7 +1826,7 @@ QDebug operator<<(QDebug d, const AbstractMetaEnum *ae)
 
 bool AbstractMetaClass::hasConstructors() const
 {
-    return !queryFunctions(Constructors).isEmpty();
+    return AbstractMetaClass::queryFirstFunction(m_functions, Constructors) != nullptr;
 }
 
 const AbstractMetaFunction *AbstractMetaClass::copyConstructor() const
@@ -1903,81 +1903,110 @@ bool AbstractMetaClass::hasFunction(const AbstractMetaFunction *f) const
    functions matching all of the criteria in \a query.
  */
 
-AbstractMetaFunctionList AbstractMetaClass::queryFunctions(FunctionQueryOptions query) const
+bool AbstractMetaClass::queryFunction(const AbstractMetaFunction *f, FunctionQueryOptions query)
 {
-    AbstractMetaFunctionList functions;
-
-    for (AbstractMetaFunction *f : m_functions) {
-        if ((query & NotRemovedFromTargetLang) && f->isRemovedFrom(f->implementingClass(), TypeSystem::TargetLangCode))
-            continue;
+    if ((query & NotRemovedFromTargetLang)
+        && f->isRemovedFrom(f->implementingClass(), TypeSystem::TargetLangCode)) {
+        return false;
+    }
 
-        if ((query & NotRemovedFromTargetLang) && f->isVirtual() && f->isRemovedFrom(f->declaringClass(), TypeSystem::TargetLangCode))
-            continue;
+    if ((query & NotRemovedFromTargetLang) && f->isVirtual()
+        && f->isRemovedFrom(f->declaringClass(), TypeSystem::TargetLangCode)) {
+        return false;
+    }
 
-        if ((query & Visible) && f->isPrivate())
-            continue;
+    if ((query & Visible) && f->isPrivate())
+        return false;
 
-        if ((query & VirtualInTargetLangFunctions) && f->isFinalInTargetLang())
-            continue;
+    if ((query & VirtualInTargetLangFunctions) && f->isFinalInTargetLang())
+        return false;
 
-        if ((query & Invisible) && !f->isPrivate())
-            continue;
+    if ((query & Invisible) && !f->isPrivate())
+        return false;
 
-        if ((query & Empty) && !f->isEmptyFunction())
-            continue;
+    if ((query & Empty) && !f->isEmptyFunction())
+        return false;
 
-        if ((query & WasPublic) && !f->wasPublic())
-            continue;
+    if ((query & WasPublic) && !f->wasPublic())
+        return false;
 
-        if ((query & ClassImplements) && f->ownerClass() != f->implementingClass())
-            continue;
+    if ((query & ClassImplements) && f->ownerClass() != f->implementingClass())
+        return false;
 
-        if ((query & FinalInTargetLangFunctions) && !f->isFinalInTargetLang())
-            continue;
+    if ((query & FinalInTargetLangFunctions) && !f->isFinalInTargetLang())
+        return false;
 
-        if ((query & VirtualInCppFunctions) && !f->isVirtual())
-            continue;
+    if ((query & VirtualInCppFunctions) && !f->isVirtual())
+        return false;
 
-        if ((query & Signals) && (!f->isSignal()))
-            continue;
+    if ((query & Signals) && (!f->isSignal()))
+        return false;
 
-        if ((query & Constructors) && (!f->isConstructor() || f->ownerClass() != f->implementingClass()))
-            continue;
+    if ((query & Constructors) && (!f->isConstructor() || f->ownerClass() != f->implementingClass()))
+        return false;
 
-        if (!(query & Constructors) && f->isConstructor())
-            continue;
+    if (!(query & Constructors) && f->isConstructor())
+        return false;
 
-        // Destructors are never included in the functions of a class currently
-        /*
+    // Destructors are never included in the functions of a class currently
+    /*
            if ((query & Destructors) && (!f->isDestructor()
                                        || f->ownerClass() != f->implementingClass())
             || f->isDestructor() && (query & Destructors) == 0) {
-            continue;
+            return false;
         }*/
 
-        if ((query & StaticFunctions) && (!f->isStatic() || f->isSignal()))
-            continue;
+    if ((query & StaticFunctions) && (!f->isStatic() || f->isSignal()))
+        return false;
 
-        if ((query & NonStaticFunctions) && (f->isStatic()))
-            continue;
+    if ((query & NonStaticFunctions) && (f->isStatic()))
+        return false;
 
-        if ((query & NormalFunctions) && (f->isSignal()))
-            continue;
+    if ((query & NormalFunctions) && (f->isSignal()))
+        return false;
 
-        if ((query & OperatorOverloads) && !f->isOperatorOverload())
-            continue;
+    if ((query & OperatorOverloads) && !f->isOperatorOverload())
+        return false;
+
+    return true;
+}
+
+AbstractMetaFunctionList AbstractMetaClass::queryFunctionList(const AbstractMetaFunctionList &list,
+                                                              FunctionQueryOptions query)
+{
+    AbstractMetaFunctionList result;
+    for (AbstractMetaFunction *f : list) {
+        if (queryFunction(f, query))
+            result.append(f);
+    }
+    return result;
+}
 
-        functions << f;
+const AbstractMetaFunction *AbstractMetaClass::queryFirstFunction(const AbstractMetaFunctionList &list,
+                                                               FunctionQueryOptions query)
+{
+    AbstractMetaFunctionList result;
+    for (AbstractMetaFunction *f : list) {
+        if (queryFunction(f, query))
+            return f;
     }
+    return nullptr;
+}
 
-    return functions;
+AbstractMetaFunctionList AbstractMetaClass::queryFunctions(FunctionQueryOptions query) const
+{
+    return AbstractMetaClass::queryFunctionList(m_functions, query);
 }
 
 bool AbstractMetaClass::hasSignals() const
 {
-    return cppSignalFunctions().size() > 0;
+    return queryFirstFunction(m_functions, Signals | Visible | NotRemovedFromTargetLang) != nullptr;
 }
 
+AbstractMetaFunctionList AbstractMetaClass::cppSignalFunctions() const
+{
+    return queryFunctions(Signals | Visible | NotRemovedFromTargetLang);
+}
 
 /**
  * Adds the specified interface to this class by adding all the
diff --git a/sources/shiboken2/ApiExtractor/abstractmetalang.h b/sources/shiboken2/ApiExtractor/abstractmetalang.h
index 128b76f5d..20c7da6e4 100644
--- a/sources/shiboken2/ApiExtractor/abstractmetalang.h
+++ b/sources/shiboken2/ApiExtractor/abstractmetalang.h
@@ -1387,9 +1387,15 @@ public:
     }
 
     AbstractMetaFunctionList queryFunctionsByName(const QString &name) const;
+    static bool queryFunction(const AbstractMetaFunction *f, FunctionQueryOptions query);
+    static AbstractMetaFunctionList queryFunctionList(const AbstractMetaFunctionList &list,
+                                                      FunctionQueryOptions query);
+    static const AbstractMetaFunction *queryFirstFunction(const AbstractMetaFunctionList &list,
+                                                          FunctionQueryOptions query);
+
     AbstractMetaFunctionList queryFunctions(FunctionQueryOptions query) const;
     AbstractMetaFunctionList functionsInTargetLang() const;
-    inline AbstractMetaFunctionList cppSignalFunctions() const;
+    AbstractMetaFunctionList cppSignalFunctions() const;
     AbstractMetaFunctionList implicitConversions() const;
 
     /**
@@ -1819,11 +1825,4 @@ private:
     int m_index = -1;
 };
 
-inline AbstractMetaFunctionList AbstractMetaClass::cppSignalFunctions() const
-{
-    return queryFunctions(Signals
-                          | Visible
-                          | NotRemovedFromTargetLang);
-}
-
 #endif // ABSTRACTMETALANG_H