1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
|
. module:: shiboken
.. |maya| unicode:: Maya U+2122
.. _shiboken-module:
Shiboken module
***************
Functions
^^^^^^^^^
.. container:: function_list
* def :meth:`isValid<shiboken.isValid>` (obj)
* def :meth:`wrapInstance<shiboken.wrapInstance>` (address, type)
* def :meth:`getCppPointer<shiboken.getCppPointer>` (obj)
* def :meth:`delete<shiboken.delete>` (obj)
* def :meth:`isOwnedByPython<shiboken.isOwnedByPython>` (obj)
* def :meth:`wasCreatedByPython<shiboken.wasCreatedByPython>` (obj)
* def :meth:`dump<shiboken.dump>` (obj)
* def :meth:`disassembleFrame<shiboken.disassembleFrame>` (marker)
Detailed description
^^^^^^^^^^^^^^^^^^^^
This Python module can be used to access internal information related to our
binding technology. Access to this internal information is required to e.g.:
integrate PySide with Qt based programs that offer Python scripting like |maya|
or just for debug purposes.
Some function description refer to "Shiboken based objects", wich means
Python objects instances of any Python Type created using Shiboken.
.. function:: isValid(obj)
Given a Python object, returns True if the object methods can be called
without an exception being thrown. A Python wrapper becomes invalid when
the underlying C++ object is destroyed or unreachable.
.. function:: wrapInstance(address, type)
Creates a Python wrapper for a C++ object instantiated at a given memory
address - the returned object type will be the same given by the user.
The type must be a Shiboken type, the C++ object will not be
destroyed when the returned Python object reach zero references.
If the address is invalid or doesn't point to a C++ object of given type
the behavior is undefined.
.. function:: getCppPointer(obj)
Returns a tuple of longs that contain the memory addresses of the
C++ instances wrapped by the given object.
.. function:: delete(obj)
Deletes the C++ object wrapped by the given Python object.
.. function:: isOwnedByPython(obj)
Given a Python object, returns True if Python is responsible for deleting
the underlying C++ object, False otherwise.
If the object was not a Shiboken based object, a TypeError is
thrown.
.. function:: wasCreatedByPython(obj)
Returns true if the given Python object was created by Python.
.. function:: dump(obj)
Returns a string with implementation-defined information about the
object.
This method should be used **only** for debug purposes by developers
creating their own bindings as no guarantee is provided that
the string format will be the same across different versions.
If the object is not a Shiboken based object, a message is printed.
.. function:: disassembleFrame(label)
Prints the current executing Python frame to stdout and flushes.
The disassembly is decorated by some label. Example:
.. code-block:: python
lambda: 42
is shown from inside C++ as
.. code-block:: c
<label> BEGIN
1 0 LOAD_CONST 1 (42)
2 RETURN_VALUE
<label> END
When you want to set a breakpoint at the `disassembleFrame` function
and you use it from C++, you use the pure function name.
When you want to use it from Python, you can insert it into your Python
code and then maybe instead set a breakpoint at `SbkShibokenModule_disassembleFrame`
which is the generated wrapper.
`label` is a simple string in C++. In Python, you can use any object;
internally the `str` function is called with it.
This method should be used **only** for debug purposes by developers.
|
