1 files changed, 54 insertions, 52 deletions

diff --git a/sources/shiboken2/libshiboken/basewrapper_p.h b/sources/shiboken2/libshiboken/basewrapper_p.h
index ebd2648e7..f8a381078 100644
--- a/sources/shiboken2/libshiboken/basewrapper_p.h
+++ b/sources/shiboken2/libshiboken/basewrapper_p.h
@@ -43,10 +43,10 @@
 #include "sbkpython.h"
 #include "basewrapper.h"
 
-#include <list>
-#include <map>
+#include <unordered_map>
 #include <set>
 #include <string>
+#include <vector>
 
 struct SbkObject;
 struct SbkObjectType;
@@ -58,7 +58,7 @@ namespace Shiboken
     * This mapping associates a method and argument of an wrapper object with the wrapper of
     * said argument when it needs the binding to help manage its reference count.
     */
-typedef std::map<std::string, std::list<PyObject*> > RefCountMap;
+typedef std::unordered_multimap<std::string, PyObject *> RefCountMap;
 
 /// Linked list of SbkBaseWrapper pointers
 typedef std::set<SbkObject*> ChildrenList;
@@ -137,6 +137,7 @@ struct SbkObjectTypePrivate
     /// Tells is the type is a value type or an object-type, see BEHAVIOUR_* constants.
     // TODO-CONVERTERS: to be deprecated/removed
     int type_behaviour : 2;
+    int delete_in_main_thread : 1;
     /// C++ name
     char* original_name;
     /// Type user data
@@ -150,10 +151,21 @@ struct SbkObjectTypePrivate
 
 namespace Shiboken
 {
+
+/**
+ * \internal
+ * Data required to invoke a C++ destructor
+ */
+struct DestructorEntry
+{
+    ObjectDestructor destructor;
+    void *cppInstance;
+};
+
 /**
  * Utility function used to transform a PyObject that implements sequence protocol into a std::list.
  **/
-std::list<SbkObject*> splitPyObject(PyObject* pyObj);
+std::vector<SbkObject *> splitPyObject(PyObject* pyObj);
 
 /**
 *   Visitor class used by walkOnClassHierarchy function.
@@ -161,81 +173,71 @@ std::list<SbkObject*> splitPyObject(PyObject* pyObj);
 class HierarchyVisitor
 {
 public:
-    HierarchyVisitor() : m_wasFinished(false) {}
-    virtual ~HierarchyVisitor() {}
-    virtual void visit(SbkObjectType* node) = 0;
-    virtual void done() {}
-    void finish() { m_wasFinished = true; };
-    bool wasFinished() const { return m_wasFinished; }
-private:
-    bool m_wasFinished;
+    HierarchyVisitor(const HierarchyVisitor &) = delete;
+    HierarchyVisitor(HierarchyVisitor &&) = delete;
+    HierarchyVisitor &operator=(const HierarchyVisitor &) = delete;
+    HierarchyVisitor &operator=(HierarchyVisitor &&) = delete;
+
+    HierarchyVisitor();
+    virtual ~HierarchyVisitor();
+
+    virtual bool visit(SbkObjectType *node) = 0; // return true to terminate
 };
 
 class BaseCountVisitor : public HierarchyVisitor
 {
 public:
-    BaseCountVisitor() : m_count(0) {}
-
-    void visit(SbkObjectType*)
-    {
-        m_count++;
-    }
+    bool visit(SbkObjectType *) override;
 
     int count() const { return m_count; }
+
 private:
-    int m_count;
+    int m_count = 0;
 };
 
 class BaseAccumulatorVisitor : public HierarchyVisitor
 {
 public:
-    BaseAccumulatorVisitor() {}
+    typedef std::vector<SbkObjectType *> Result;
 
-    void visit(SbkObjectType* node)
-    {
-        m_bases.push_back(node);
-    }
+    bool visit(SbkObjectType *node) override;
+
+    Result bases() const { return m_bases; }
 
-    std::list<SbkObjectType*> bases() const { return m_bases; }
 private:
-    std::list<SbkObjectType*> m_bases;
+    Result m_bases;
 };
 
 class GetIndexVisitor : public HierarchyVisitor
 {
 public:
-    GetIndexVisitor(PyTypeObject* desiredType) : m_index(-1), m_desiredType(desiredType) {}
-    virtual void visit(SbkObjectType* node)
-    {
-        m_index++;
-        if (PyType_IsSubtype(reinterpret_cast<PyTypeObject*>(node), m_desiredType))
-            finish();
-    }
+    explicit GetIndexVisitor(PyTypeObject* desiredType) : m_desiredType(desiredType) {}
+
+    bool visit(SbkObjectType *node) override;
+
     int index() const { return m_index; }
 
 private:
-    int m_index;
-    PyTypeObject* m_desiredType;
+    int m_index = -1;
+    PyTypeObject *m_desiredType;
 };
 
-/// Call the destructor of each C++ object held by a Python object
-class DtorCallerVisitor : public HierarchyVisitor
+/// Collect destructors and C++ instances of each C++ object held by a Python
+/// object
+class DtorAccumulatorVisitor : public HierarchyVisitor
 {
 public:
-    DtorCallerVisitor(SbkObject* pyObj) : m_pyObj(pyObj) {}
-    void visit(SbkObjectType* node);
-    void done();
-protected:
-    std::list<std::pair<void*, SbkObjectType*> > m_ptrs;
-    SbkObject* m_pyObj;
-};
+    explicit DtorAccumulatorVisitor(SbkObject *pyObj) : m_pyObject(pyObj) {}
 
-/// Dealloc of each C++ object held by a Python object, this implies a call to the C++ object destructor
-class DeallocVisitor : public DtorCallerVisitor
-{
-public:
-    DeallocVisitor(SbkObject* pyObj) : DtorCallerVisitor(pyObj) {}
-    void done();
+    bool visit(SbkObjectType *node) override;
+
+    using DestructorEntries = std::vector<DestructorEntry>;
+
+    const DestructorEntries &entries() const { return m_entries; }
+
+private:
+    DestructorEntries m_entries;
+    SbkObject *m_pyObject;
 };
 
 /// \internal Internal function used to walk on classes inheritance trees.
@@ -244,7 +246,7 @@ public:
 *   For each pure Shiboken type found, HiearchyVisitor::visit is called and the algorithm consider
 *   all children of this type as visited.
 */
-void walkThroughClassHierarchy(PyTypeObject* currentType, HierarchyVisitor* visitor);
+bool walkThroughClassHierarchy(PyTypeObject *currentType, HierarchyVisitor *visitor);
 
 inline int getTypeIndexOnHierarchy(PyTypeObject* baseType, PyTypeObject* desiredType)
 {
@@ -260,7 +262,7 @@ inline int getNumberOfCppBaseClasses(PyTypeObject* baseType)
     return visitor.count();
 }
 
-inline std::list<SbkObjectType*> getCppBaseClasses(PyTypeObject* baseType)
+inline std::vector<SbkObjectType *> getCppBaseClasses(PyTypeObject* baseType)
 {
     BaseAccumulatorVisitor visitor;
     walkThroughClassHierarchy(baseType, &visitor);