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;
+               }
+             }
-             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 NULL;
                }
-               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 +12 -5

                 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
-                        if (PythonQtClassInfo::hasEnum(info.name, meta)) {
-                          unsigned int val = (unsigned int)PyObjGetLongLong(obj, strict, ok);
+                      if (info.enumWrapper) {
+                        unsigned int val;
+                        if ((PyObject*)obj->ob_type == info.enumWrapper) {
+                          // we have a direct enum type match:
+                          val = PyInt_AS_LONG(obj);
+                          ok = true;
+                        } else {
+                          // 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;
-                            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
-               static void* ConvertPythonToQt(const PythonQtMethodInfo::ParameterInfo& info, PyObject* obj, bool strict, PythonQtClassInfo* meta, void* alreadyAllocatedCPPObject = NULL);
+               //! 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* 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 +5 -7

                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) {
-                     returnValueIsEnum = PythonQtClassInfo::hasEnum(returnValueParam.name, classInfo);
-                     if (returnValueIsEnum) {
+                   if (!returnValueParam.isPointer && returnValueParam.enumWrapper) {
-                       // create enum return value
-                       PythonQtValueStorage_ADD_VALUE(PythonQtConv::global_valueStorage, long, 0, argList[0]);
+                     }
+                   }
-                   if (argList[0]==NULL) {
+                     returnValueIsEnum = true;
+                   } else {
                      // 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