GIT_REPOSITORIES/LPP/PythonQt Commit - r55:83868d7a7982

cache enumWrappers in method infos and make use of the extra information for better enum overloading...

florianlink -

r55:83868d7a7982

parent child

Context file:

r55:83868d7a7982

Collapse all files

src/PythonQt.cpp +2 -1

                 QMetaMethod m = o->metaObject()->method(i);
                 if ((m.methodType() == QMetaMethod::Method ||
                   m.methodType() == QMetaMethod::Slot) && m.access() == QMetaMethod::Public) {
-                  const PythonQtMethodInfo* info = PythonQtMethodInfo::getCachedMethodInfo(m, NULL);
                   if (qstrncmp(m.signature(), "new_", 4)==0) {
                     if ((decoTypes & ConstructorDecorator) == 0) continue;
+                    const PythonQtMethodInfo* info = PythonQtMethodInfo::getCachedMethodInfo(m, NULL);
                     if (info->parameters().at(0).isPointer) {
                       QByteArray signature = m.signature();
                       QByteArray nameOfClass = signature.mid(4, signature.indexOf('(')-4);
                     classInfo->addDecoratorSlot(newSlot);
                   } else {
                     if ((decoTypes & InstanceDecorator) == 0) continue;
+                    const PythonQtMethodInfo* info = PythonQtMethodInfo::getCachedMethodInfo(m, NULL);
                     if (info->parameters().count()>1) {
                       PythonQtMethodInfo::ParameterInfo p = info->parameters().at(1);
                       if (p.isPointer) {

src/PythonQtClassInfo.cpp +13 -26

               int enumCount = meta->enumeratorCount();
               for (int i=0;i<enumCount; i++) {
                 QMetaEnum e = meta->enumerator(i);
+                // we do not want flags, they will cause our values to appear two times
+                if (e.isFlag()) continue;
                 for (int j=0; j < e.keyCount(); j++) {
                   if (qstrcmp(e.key(j), memberName)==0) {
                     PyObject* enumType = findEnumWrapper(e.name());
                 for (int i = 0; i<meta->enumeratorCount(); i++) {
                   QMetaEnum e = meta->enumerator(i);
                   l << e.name();
+                  // we do not want flags, they will cause our values to appear two times
+                  if (e.isFlag()) continue;
                   for (int j=0; j < e.keyCount(); j++) {
                     l << QString(e.key(j));
                   }
               return resultPtr;
             }
-            bool PythonQtClassInfo::hasEnum(const QByteArray& name, PythonQtClassInfo* localScope)
+            PyObject* PythonQtClassInfo::findEnumWrapper(const QByteArray& name, PythonQtClassInfo* localScope, bool& isLocalEnum)
             {
+              isLocalEnum = true;
               int scopePos = name.lastIndexOf("::");
               if (scopePos != -1) {
+                isLocalEnum = false;
                 // slit into scope and enum name
                 QByteArray enumScope = name.mid(0,scopePos);
                 QByteArray enumName = name.mid(scopePos+2);
                 PythonQtClassInfo* info = PythonQt::priv()->getClassInfo(enumScope);
                 if (info) {
-                  return info->hasEnum(enumName);
+                  return info->findEnumWrapper(enumName);
                 } else{
-                  return false;
+                  return NULL;
                 }
               }
               if (localScope) {
-                return localScope->hasEnum(name);
+                return localScope->findEnumWrapper(name);
               } else {
-                return false;
+                return NULL;
-            bool PythonQtClassInfo::hasEnum(const QByteArray& name)
-              bool found = false;
-              if (_meta) {
-                found = _meta->indexOfEnumerator(name)!=-1;
-              if (!found) {
-                // check enums in the class hierachy of CPP classes
-                // look for dynamic decorators in this class and in derived classes
-                QList<QObject*> decoObjects;
-                recursiveCollectDecoratorObjects(decoObjects);
-                foreach(QObject* deco, decoObjects) {
-                  found = deco->metaObject()->indexOfEnumerator(name)!=-1;
-                  if (found) {
-                    break;
               }
-              return found;
             }
             void PythonQtClassInfo::createEnumWrappers(const QMetaObject* meta)

src/PythonQtClassInfo.h +1 -4

               void* castDownIfPossible(void* ptr, PythonQtClassInfo** resultClassInfo);
               //! returns if the localScope has an enum of that type name or if the enum contains a :: scope, if that class contails the enum
-              static bool hasEnum(const QByteArray& name, PythonQtClassInfo* localScope);
+              static PyObject* findEnumWrapper(const QByteArray& name, PythonQtClassInfo* localScope, bool& isLocalEnum);
             private:
               void createEnumWrappers();
               void createEnumWrappers(const QMetaObject* meta);
               PyObject* findEnumWrapper(const char* name);
-              //! checks if the enum is part of this class (without any leading scope!)
-              bool hasEnum(const QByteArray& name);
               //! clear all cached members
               void clearCachedMembers();

src/PythonQtConversion.cpp +18 -11

                return object;
              }
-             void* PythonQtConv::ConvertPythonToQt(const PythonQtMethodInfo::ParameterInfo& info, PyObject* obj, bool strict, PythonQtClassInfo* meta, void* alreadyAllocatedCPPObject)
+             void* PythonQtConv::ConvertPythonToQt(const PythonQtMethodInfo::ParameterInfo& info, PyObject* obj, bool strict, PythonQtClassInfo* /*classInfo*/, void* alreadyAllocatedCPPObject)
              {
                bool ok;
                void* ptr = NULL;
                    break;
                    default:
                    {
-                     if (info.typeId == PythonQtMethodInfo::Unknown) {
+                     // check for enum case
-                       // check for enum case
+                     if (info.enumWrapper) {
-                       if (PythonQtClassInfo::hasEnum(info.name, meta)) {
+                       unsigned int val;
-                         unsigned int val = (unsigned int)PyObjGetLongLong(obj, strict, ok);
+                       if ((PyObject*)obj->ob_type == info.enumWrapper) {
-                         if (ok) {
+                         // we have a direct enum type match:
-                           PythonQtValueStorage_ADD_VALUE_IF_NEEDED(alreadyAllocatedCPPObject,global_valueStorage, unsigned int, val, ptr);
+                         val = PyInt_AS_LONG(obj);
-                           return ptr;
+                         ok = true;
-                         } else {
+                       } else {
-                           return NULL;
+                         // we try to get an integer, and in strict mode, it may not be a derived int class, so that no other enum can be taken as an int
+                         val = (unsigned int)PyObjGetLongLong(obj, strict, ok);
+                       }
+                       if (ok) {
+                         PythonQtValueStorage_ADD_VALUE_IF_NEEDED(alreadyAllocatedCPPObject,global_valueStorage, unsigned int, val, ptr);
+                         return ptr;
+                       } else {
+                         return NULL;
                        }
                      }
                      if (info.typeId == PythonQtMethodInfo::Unknown || info.typeId >= QMetaType::User) {
                        // check for QList<AnyPtr*> case, where we will use a QList<void*> QVariant
                        if (info.name.startsWith("QList<")) {

src/PythonQtConversion.h +2 -2

               //! converts the Qt parameter given in \c data, interpreting it as a \c info parameter, into a Python object,
               static PyObject* ConvertQtValueToPython(const PythonQtMethodInfo::ParameterInfo& info, const void* data);
-              //! convert python object to Qt (according to the given parameter) and if the conversion should be strict, the meta object is passed in for enum resolving
+              //! convert python object to Qt (according to the given parameter) and if the conversion should be strict (classInfo is currently not used anymore)
-              static void* ConvertPythonToQt(const PythonQtMethodInfo::ParameterInfo& info, PyObject* obj, bool strict, PythonQtClassInfo* meta, void* alreadyAllocatedCPPObject = NULL);
+              static void* ConvertPythonToQt(const PythonQtMethodInfo::ParameterInfo& info, PyObject* obj, bool strict, PythonQtClassInfo* classInfo, void* alreadyAllocatedCPPObject = NULL);
               //! creates a data storage for the passed parameter type and returns a void pointer to be set as arg[0] of qt_metacall
               static void* CreateQtReturnValue(const PythonQtMethodInfo::ParameterInfo& info);

src/PythonQtInstanceWrapper.cpp +2 -2

               self->ob_type->tp_free((PyObject*)self);
             }
-            static PyObject* PythonQtInstanceWrapper_new(PyTypeObject *type, PyObject * args, PyObject * /*kwds*/)
+            static PyObject* PythonQtInstanceWrapper_new(PyTypeObject *type, PyObject * /*args*/, PyObject * /*kwds*/)
             {
               //PythonQtClassWrapper    *classType = (PythonQtClassWrapper*)type;
               PythonQtInstanceWrapper *self;
                   return PyString_FromFormat("%s (C++ Object %p)", typeName, wrapper->_wrappedPtr);
                 }
               } else {
-                return PyString_FromFormat("%s (QObject %p)", typeName, wrapper->classInfo()->className(), qobj);
+                return PyString_FromFormat("%s (%s %p)", typeName, wrapper->classInfo()->className(), qobj);
               }
             }

src/PythonQtMethodInfo.cpp +11 -3

             #endif
               ParameterInfo type;
-              fillParameterInfo(type, QByteArray(meta.typeName()));
+              fillParameterInfo(type, QByteArray(meta.typeName()), classInfo);
               _parameters.append(type);
               QByteArray name;
               QList<QByteArray> names = meta.parameterTypes();
               foreach (name, names) {
-                fillParameterInfo(type, name);
+                fillParameterInfo(type, name, classInfo);
                 _parameters.append(type);
               }
             }
               return PythonQtMethodInfo::getCachedMethodInfo(meta, NULL);
             }
-            void PythonQtMethodInfo::fillParameterInfo(ParameterInfo& type, const QByteArray& orgName)
+            void PythonQtMethodInfo::fillParameterInfo(ParameterInfo& type, const QByteArray& orgName, PythonQtClassInfo* classInfo)
             {
               QByteArray name = orgName;
+              type.enumWrapper = NULL;
               int len = name.length();
               if (len>0) {
                 if (strncmp(name.constData(), "const ", 6)==0) {
                   }
                 }
                 type.name = name;
+                if (type.typeId == PythonQtMethodInfo::Unknown || type.typeId >= QMetaType::User) {
+                  bool isLocalEnum;
+                  // TODOXXX: make use of this flag!
+                  type.enumWrapper = PythonQtClassInfo::findEnumWrapper(type.name, classInfo, isLocalEnum);
+                }
               } else {
                 type.typeId = QMetaType::Void;
                 type.isPointer = false;

src/PythonQtMethodInfo.h +5 -2

             #include <QMetaMethod>
             class PythonQtClassInfo;
+            struct _object;
+            typedef struct _object PyObject;
             //! stores information about a specific signal/slot/method
             class PYTHONQT_EXPORT PythonQtMethodInfo
               //! stores the QVariant id (if available) and the name of the type
               struct ParameterInfo {
-                int typeId; // a mixture from QMetaType and ParameterType
                 QByteArray name;
+                PyObject*  enumWrapper; // if it is an enum, a pointer to the enum wrapper
+                int typeId; // a mixture from QMetaType and ParameterType
                 bool isPointer;
                 bool isConst;
               };
               static void addParameterTypeAlias(const QByteArray& alias, const QByteArray& name);
               protected:
-              static void fillParameterInfo(ParameterInfo& type, const QByteArray& name);
+              static void fillParameterInfo(ParameterInfo& type, const QByteArray& name, PythonQtClassInfo* classInfo);
               static QHash<QByteArray, int> _parameterTypeDict;
               static QHash<QByteArray, QByteArray> _parameterNameAliases;

src/PythonQtSlot.cpp +7 -9

               int argc = info->parameterCount();
               const QList<PythonQtSlotInfo::ParameterInfo>& params = info->parameters();
-              bool returnValueIsEnum = false;
               const PythonQtSlotInfo::ParameterInfo& returnValueParam = params.at(0);
               // set return argument to NULL
               argList[0] = NULL;
               }
               if (ok) {
+                bool returnValueIsEnum = false;
                 // parameters are ok, now create the qt return value which is assigned to by metacall
                 if (returnValueParam.typeId != QMetaType::Void) {
                   // extra handling of enum return value
-                  if (!returnValueParam.isPointer && returnValueParam.typeId == PythonQtMethodInfo::Unknown) {
+                  if (!returnValueParam.isPointer && returnValueParam.enumWrapper) {
-                    returnValueIsEnum = PythonQtClassInfo::hasEnum(returnValueParam.name, classInfo);
+                    // create enum return value
-                    if (returnValueIsEnum) {
+                    PythonQtValueStorage_ADD_VALUE(PythonQtConv::global_valueStorage, long, 0, argList[0]);
-                      // create enum return value
+                    returnValueIsEnum = true;
-                      PythonQtValueStorage_ADD_VALUE(PythonQtConv::global_valueStorage, long, 0, argList[0]);
+                  } else {
-                  if (argList[0]==NULL) {
                     // create empty default value for the return value
                     if (!directReturnValuePointer) {
                       // create empty default value for the return value

General Comments 0

Write
Preview

You need to be logged in to leave comments. Login now

No TODOs yet

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages