1 files changed, 167 insertions, 0 deletions
diff --git a/sources/shiboken6/libshiboken/basewrapper_p.h b/sources/shiboken6/libshiboken/basewrapper_p.h
new file mode 100644
index 000000000..fb9140793
--- /dev/null
+++ b/sources/shiboken6/libshiboken/basewrapper_p.h
@@ -0,0 +1,167 @@
+// Copyright (C) 2016 The Qt Company Ltd.
+// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
+
+#ifndef BASEWRAPPER_P_H
+#define BASEWRAPPER_P_H
+
+#include "sbkpython.h"
+#include "basewrapper.h"
+
+#include <unordered_map>
+#include <set>
+#include <string>
+#include <vector>
+#include <iosfwd>
+
+struct SbkObject;
+struct SbkConverter;
+
+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.
+    */
+using RefCountMap = std::unordered_multimap<std::string, PyObject *> ;
+
+/// Linked list of SbkBaseWrapper pointers
+using ChildrenList = std::set<SbkObject *>;
+
+/// Structure used to store information about object parent and children.
+struct ParentInfo
+{
+    /// Pointer to parent object.
+    SbkObject *parent = nullptr;
+    /// List of object children.
+    ChildrenList children;
+    /// has internal ref
+    bool hasWrapperRef = false;
+};
+
+} // namespace Shiboken
+
+extern "C"
+{
+
+/**
+ * \internal
+ * Private data for SbkBaseWrapper
+ */
+struct SbkObjectPrivate
+{
+    SbkObjectPrivate() noexcept = default;
+    SbkObjectPrivate(const SbkObjectPrivate &) = delete;
+    SbkObjectPrivate(SbkObjectPrivate &&o) = delete;
+    SbkObjectPrivate &operator=(const SbkObjectPrivate &) = delete;
+    SbkObjectPrivate &operator=(SbkObjectPrivate &&o) = delete;
+
+    /// Pointer to the C++ class.
+    void ** cptr;
+    /// True when Python is responsible for freeing the used memory.
+    unsigned int hasOwnership : 1;
+    /// This is true when the C++ class of the wrapped object has a virtual destructor AND was created by Python.
+    unsigned int containsCppWrapper : 1;
+    /// Marked as false when the object is lost to C++ and the binding can not know if it was deleted or not.
+    unsigned int validCppObject : 1;
+    /// Marked as true when the object constructor was called
+    unsigned int cppObjectCreated : 1;
+    /// PYSIDE-1470: Marked as true if this is the Q*Application singleton.
+    /// This bit allows app deletion from shiboken?.delete() .
+    unsigned int isQAppSingleton : 1;
+    /// Information about the object parents and children, may be null.
+    Shiboken::ParentInfo *parentInfo;
+    /// Manage reference count of objects that are referred to but not owned from.
+    Shiboken::RefCountMap *referredObjects;
+
+    ~SbkObjectPrivate()
+    {
+        delete parentInfo;
+        parentInfo = nullptr;
+        delete referredObjects;
+        referredObjects = nullptr;
+    }
+};
+
+// TODO-CONVERTERS: to be deprecated/removed
+/// The type behaviour was not defined yet
+#define BEHAVIOUR_UNDEFINED 0
+/// The type is a value type
+#define BEHAVIOUR_VALUETYPE 1
+/// The type is an object type
+#define BEHAVIOUR_OBJECTTYPE 2
+
+struct SbkObjectTypePrivate
+{
+    SbkConverter *converter;
+    int *mi_offsets;
+    MultipleInheritanceInitFunction mi_init;
+
+    /// Special cast function, null if this class doesn't have multiple inheritance.
+    SpecialCastFunction mi_specialcast;
+    TypeDiscoveryFuncV2 type_discovery;
+    /// Pointer to a function responsible for deletion of the C++ instance calling the proper destructor.
+    ObjectDestructor cpp_dtor;
+    /// C++ name
+    char *original_name;
+    /// Type user data
+    void *user_data;
+    DeleteUserDataFunc d_func;
+    void (*subtype_init)(PyTypeObject *, PyObject *, PyObject *);
+    const char **propertyStrings;
+    const char **enumFlagInfo;
+    PyObject *enumFlagsDict;
+    PyObject *enumTypeDict;
+
+    /// True if this type holds two or more C++ instances, e.g.: a Python class which inherits from two C++ classes.
+    unsigned int is_multicpp : 1;
+    /// True if this type was defined by the user (a class written in Python inheriting
+    /// a class provided by a Shiboken binding).
+    unsigned int is_user_type : 1;
+    /// Tells is the type is a value type or an object-type, see BEHAVIOUR_ *constants.
+    unsigned int type_behaviour : 2;
+    unsigned int delete_in_main_thread : 1;
+};
+
+
+} // extern "C"
+
+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::vector<SbkObject *> splitPyObject(PyObject *pyObj);
+
+int getNumberOfCppBaseClasses(PyTypeObject *baseType);
+
+namespace Object
+{
+/**
+*   Decrements the reference counters of every object referred by self.
+*   \param self    the wrapper instance that keeps references to other objects.
+*/
+void clearReferences(SbkObject *self);
+
+/**
+ * Destroy internal data
+ **/
+void deallocData(SbkObject *self, bool doCleanup);
+
+
+void _debugFormat(std::ostream &str, SbkObject *self);
+} // namespace Object
+
+} // namespace Shiboken
+
+#endif