Create a separate receiver object for each signal/callable connect

This way we can't run out of slot IDs.
This fixes #362
This also enables us to associate the receiver with the instance object
of the callable (if it is a method of a QObject-derived class) instead
of the sender, so that it is associated with the correct thread, which
is important for the AutoConnection used.
In a way this also fixes the problem in #363

[pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci

Author: usiems

src/PythonQt.cpp

@@ -34,7 +34,6 @@
 /*!
 // \file    PythonQt.cpp
 // \author  Florian Link
-// \author  Last changed by $Author: florian $
 // \date    2006-05
 */
 //----------------------------------------------------------------------------------
@@ -324,8 +323,7 @@ void PythonQt::init(int flags, const QByteArray& pythonQtModuleName)
 void PythonQt::cleanup()
 {
   if (_self) {
-    // Remove signal handlers in advance, since destroying them calls back into
-    // PythonQt::priv()->removeSignalEmitter()
+    // Remove all created signal receivers
     _self->removeSignalHandlers();
 
     delete _self;
@@ -879,65 +877,36 @@ PyObject* PythonQtPrivate::createNewPythonQtEnumWrapper(const char* enumName, Py
   return result;
 }
 
-PythonQtSignalReceiver* PythonQt::getSignalReceiver(QObject* obj)
-{
-  PythonQtSignalReceiver* r = _p->_signalReceivers[obj];
-  if (!r) {
-    r = new PythonQtSignalReceiver(obj);
-    _p->_signalReceivers.insert(obj, r);
-  }
-  return r;
-}
-
 bool PythonQt::addSignalHandler(QObject* obj, const char* signal, PyObject* module, const QString& objectname)
 {
-  bool flag = false;
   PythonQtObjectPtr callable = lookupCallable(module, objectname);
   if (callable) {
-    PythonQtSignalReceiver* r = getSignalReceiver(obj);
-    flag = r->addSignalHandler(signal, callable);
-    if (!flag) {
-      // signal not found
-    }
+    return _p->addSignalHandler(obj, signal, callable);
   } else {
     // callable not found
   }
-  return flag;
+  return false;
 }
 
-bool PythonQt::addSignalHandler(QObject* obj, const char* signal, PyObject* receiver)
+bool PythonQt::addSignalHandler(QObject* obj, const char* signal, PyObject* callable)
 {
-  bool flag = false;
-  PythonQtSignalReceiver* r = getSignalReceiver(obj);
-  if (r) {
-    flag = r->addSignalHandler(signal, receiver);
-  }
-  return flag;
+  return _p->addSignalHandler(obj, signal, callable);
 }
 
 bool PythonQt::removeSignalHandler(QObject* obj, const char* signal, PyObject* module, const QString& objectname)
 {
-  bool flag = false;
   PythonQtObjectPtr callable = lookupCallable(module, objectname);
   if (callable) {
-    PythonQtSignalReceiver* r = _p->_signalReceivers[obj];
-    if (r) {
-      flag = r->removeSignalHandler(signal, callable);
-    }
+    return _p->removeSignalHandler(obj, signal, callable);
   } else {
     // callable not found
   }
-  return flag;
+  return false;
 }
 
-bool PythonQt::removeSignalHandler(QObject* obj, const char* signal, PyObject* receiver)
+bool PythonQt::removeSignalHandler(QObject* obj, const char* signal, PyObject* callable)
 {
-  bool flag = false;
-  PythonQtSignalReceiver* r = _p->_signalReceivers[obj];
-  if (r) {
-    flag = r->removeSignalHandler(signal, receiver);
-  }
-  return flag;
+  return _p->removeSignalHandler(obj, signal, callable);
 }
 
 PythonQtObjectPtr PythonQt::lookupCallable(PyObject* module, const QString& name)
@@ -1619,20 +1588,14 @@ void PythonQtPrivate::registerQObjectClassNames(const QStringList& names)
   }
 }
 
-void PythonQtPrivate::removeSignalEmitter(QObject* obj)
-{
-  _signalReceivers.remove(obj);
-}
-
 void PythonQt::removeSignalHandlers()
 {
-  QList<PythonQtSignalReceiver*> signalReceivers = _p->_signalReceivers.values();
-
-  // just delete all signal receivers, they will remove themselves via removeSignalEmitter()
-  for (PythonQtSignalReceiver* receiver : qAsConst(signalReceivers)) {
-    delete receiver;
+  auto it = _p->_signalReceivers.begin();
+  while (it != _p->_signalReceivers.end()) {
+    it.value()->markAsRemoved();
+    delete it.value();
+    it++;
   }
-  // just to be sure, clear the receiver map as well
   _p->_signalReceivers.clear();
 }
 
@@ -2012,6 +1975,57 @@ PythonQtClassInfo* PythonQtPrivate::lookupClassInfoAndCreateIfNotPresent(const c
   return info;
 }
 
+bool PythonQtPrivate::addSignalHandler(QObject* sender, const char* signal, PyObject* callable)
+{
+  // Note: It is assumed that the GIL is held when this is called
+  bool ok = false;
+  int sigId = PythonQtSignalReceiver::getSignalIndex(sender, signal);
+  if (sigId >= 0) {
+    // create PythonQtMethodInfo from signal
+    auto* receiver = new PythonQtSignalReceiver(sender, sigId, callable);
+    _signalReceivers.insert(SignalKey(sender, sigId), receiver);
+    ok = true;
+  }
+  return ok;
+}
+
+bool PythonQtPrivate::removeSignalHandler(QObject* sender, const char* signal, PyObject* callable)
+{
+  // Note: It is assumed that the GIL is held when this is called
+  int foundCount = 0;
+  int sigId = PythonQtSignalReceiver::getSignalIndex(sender, signal);
+  if (sigId >= 0) {
+    SignalKey hashKey(sender, sigId);
+    auto it = _signalReceivers.find(hashKey);
+    while (it != _signalReceivers.end() && it.key() == hashKey) {
+      if (!callable || it.value()->isSameCallable(callable)) {
+        it.value()->markAsRemoved();
+        // delete later in case the connection is removed from the receiver callable itself
+        it.value()->deleteLater();
+        foundCount++;
+        it = _signalReceivers.erase(it);
+      } else {
+        it++;
+      }
+    }
+  }
+  return foundCount > 0;
+}
+
+void PythonQtPrivate::removeSignalReceiver(PythonQtSignalReceiver* receiver)
+{
+  PYTHONQT_GIL_SCOPE
+  SignalKey hashKey(receiver->sender(), receiver->signalId());
+  auto it = _signalReceivers.find(hashKey);
+  while (it != _signalReceivers.end() && it.key() == hashKey) {
+    if (it.value() == receiver) {
+      _signalReceivers.erase(it);
+      break; // each receiver is only entered once
+    }
+    it++;
+  }
+}
+
 void PythonQt::addPolymorphicHandler(const char* typeName, PythonQtPolymorphicHandlerCB* cb)
 {
   _p->addPolymorphicHandler(typeName, cb);

src/PythonQt.h

@@ -37,7 +37,6 @@
 /*!
 // \file    PythonQt.h
 // \author  Florian Link
-// \author  Last changed by $Author: florian $
 // \date    2006-05
 */
 //----------------------------------------------------------------------------------
@@ -55,6 +54,7 @@
 #include <QVariant>
 #include <QList>
 #include <QHash>
+#include <QMultiHash>
 #include <QByteArray>
 #include <QStringList>
 #include <QtDebug>
@@ -654,9 +654,6 @@ class PYTHONQT_EXPORT PythonQt : public QObject
   //! callback for stderr redirection, emits pythonStdErr signal
   static void stdErrRedirectCB(const QString& str);
 
-  //! get (and create if not available) the signal receiver of that QObject, signal receiver is made child of the passed \c obj
-  PythonQtSignalReceiver* getSignalReceiver(QObject* obj);
-
   PythonQt(int flags, const QByteArray& pythonQtModuleName);
   ~PythonQt() override;
   static PythonQt* _self;
@@ -729,8 +726,18 @@ class PYTHONQT_EXPORT PythonQtPrivate : public QObject
   //! lookup existing classinfo and return new if not yet present
   PythonQtClassInfo* lookupClassInfoAndCreateIfNotPresent(const char* typeName);
 
-  //! called when a signal emitting QObject is destroyed to remove the signal handler from the hash map
-  void removeSignalEmitter(QObject* obj);
+  //! add a signal handler
+  //!
+  //! The GIL should be held when calling this
+  bool addSignalHandler(QObject* sender, const char* signal, PyObject* callable);
+
+  //! remove a signal handler for given callable (or all callables on that signal if callable is NULL)
+  //!
+  //! The GIL should be held when calling this
+  bool removeSignalHandler(QObject* sender, const char* signal, PyObject* callable = nullptr);
+
+  //! called when a signal receiver is deleted to remove it from the hash map
+  void removeSignalReceiver(PythonQtSignalReceiver* receiver);
 
   //! wrap the given QObject into a Python object (or return existing wrapper!)
   PyObject* wrapQObject(QObject* obj);
@@ -865,7 +872,8 @@ class PYTHONQT_EXPORT PythonQtPrivate : public QObject
   QHash<QByteArray, QByteArray> _knownLazyClasses;
 
   //! stores signal receivers for QObjects
-  QHash<QObject*, PythonQtSignalReceiver*> _signalReceivers;
+  typedef QPair<QObject*, int> SignalKey;
+  QMultiHash<SignalKey, PythonQtSignalReceiver*> _signalReceivers;
 
   //! the PythonQt python module
   PythonQtObjectPtr _pythonQtModule;