Type System Variables¶
User written code can be placed in arbitrary places using the inject-code tag. To ease the binding developer work, the injected code can make use of special variables that will be replaced by the correct values. This also shields the developer from some Shiboken implementation specifics.
Variables¶
%0
Replaced by the C++ return variable of the Python method/function wrapper.
%<number>
Replaced by the name of a C++ argument in the position indicated by
<number>
. The argument counting starts with%1
, since%0
represents the return variable name. If the number indicates a variable that was removed in the type system description, but there is a default value for it, this value will be used. Consider this example:void argRemoval(int a0, int a1 = 123);<modify-function signature="argRemoval(int, int)"> <modify-argument index="2"> <remove-argument/> </modify-argument> </modify-function>The
%1
will be replaced by the C++ argument name, and%2
will get the value123
.
%ARGUMENT_NAMES
Replaced by a comma separated list with the names of all C++ arguments that were not removed on the type system description for the method/function. When the removed argument has a default value (original or provided in the type system), this value will be inserted in the argument list. If you want to remove the argument so completely that it doesn’t appear in any form on the
%ARGUMENT_NAMES
replacement, don’t forget to remove also its default value with the remove-default-expression type system tag.Take the following method and related type system description as an example:
void argRemoval(int a0, Point a1 = Point(1, 2), bool a2 = true, Point a3 = Point(3, 4), int a4 = 56);<modify-function signature="argRemoval(int, Point, bool, Point, int)"> <modify-argument index="2"> <remove-argument/> <replace-default-expression with="Point(6, 9)"/> </modify-argument> <modify-argument index="4"> <remove-argument/> </modify-argument> </modify-function>As seen on the XML description, the function’s
a1
anda3
arguments were removed. If anyinject-code
for this function uses%ARGUMENT_NAMES
the resulting list will be the equivalent of using individual argument type system variables this way:%1, Point(6, 9), %3, Point(3, 4), %5
%ARG#_TYPE
Replaced by the type of a C++ argument in the position indicated by
#
. The argument counting starts with%1
, since%0
represents the return variable in other contexts, but%ARG0_TYPE
will not translate to the return type, as this is already done by the %RETURN_TYPE variable. Example:void argRemoval(int a0, int a1 = 123);<modify-function signature="argRemoval(int, int)"> <modify-argument index="2"> <remove-argument/> </modify-argument> </modify-function>The
%1
will be replaced by the C++ argument name, and%2
will get the value123
.
%CONVERTTOCPP[CPPTYPE]
Replaced by a Shiboken conversion call that converts a Python variable to a C++ variable of the type indicated by
CPPTYPE
.Typically, this is a variable assignment:
double value = %CONVERTTOCPP[double](pyValue);Pointer assignments are also possible:
void f(double *valuePtr) { *valuePtr = %CONVERTTOCPP[double](pyValue);Note however, that for variable definitions, the type must be a space-delimited token:
double * valuePtr = %CONVERTTOCPP[double](pyValue);since it otherwise would be indistinguishable from the pointer assignment above.
It is possible to use “auto” as type.
%CONVERTTOPYTHON[CPPTYPE]
Replaced by a Shiboken conversion call that converts a C++ variable of the type indicated by
CPPTYPE
to the proper Python object.
%ISCONVERTIBLE[CPPTYPE]
Replaced by a Shiboken “isConvertible” call that checks if a Python variable is convertible (via an implicit conversion or cast operator call) to a C++ variable of the type indicated by
CPPTYPE
.
%CHECKTYPE[CPPTYPE]
Replaced by a Shiboken “checkType” call that verifies if a Python if of the type indicated by
CPPTYPE
.
%CPPSELF
Replaced by the wrapped C++ object instance that owns the method in which the code with this variable was inserted.
%CPPTYPE
Replaced by the original name of the C++ class, without any namespace prefix, that owns the method in which the code with this variable was inserted. It will work on class level code injections also. Notice that
CPPTYPE
differs from the %TYPE variable, for this latter may be translated to the original C++ class name or to the C++ wrapper class name.Namespaces will are treated as classes, so
CPPTYPE
will work for them and their enclosed functions as well.
%FUNCTION_NAME
Replaced by the name of a function or method.
%PYARG_0
Replaced by the name of the Python return variable of the Python method/function wrapper.
%PYARG_<number>
Similar to
%<number>
, but is replaced by the Python arguments (PyObjects) received by the Python wrapper method.If used in the context of a native code injection, i.e. in a virtual method override,
%PYARG_<number>
will be translated to one item of the Python tuple holding the arguments that should be passed to the Python override for this virtual method.The example
long a = PyInt_AS_LONG(%PYARG_1);is equivalent of
long a = PyInt_AS_LONG(PyTuple_GET_ITEM(%PYTHON_ARGUMENTS, 0));The generator tries to be smart with attributions, but it will work for the only simplest cases.
This example
Py_DECREF(%PYARG_1); %PYARG_1 = PyInt_FromLong(10);is equivalent of
Py_DECREF(PyTuple_GET_ITEM(%PYTHON_ARGUMENTS, 0)); PyTuple_SET_ITEM(%PYTHON_ARGUMENTS, 0, PyInt_FromLong(10));
%PYSELF
Replaced by the Python wrapper variable (a PyObject) representing the instance bounded to the Python wrapper method which receives the custom code.
%PYTHON_ARGUMENTS
Replaced by the pointer to the Python tuple with Python objects converted from the C++ arguments received on the binding override of a virtual method. This tuple is the same passed as arguments to the Python method overriding the C++ parent’s one.
%PYTHON_METHOD_OVERRIDE
This variable is used only on native method code injections, i.e. on the binding overrides for C++ virtual methods. It is replaced by a pointer to the Python method override.
%PYTHONTYPEOBJECT
Replaced by the Python type object for the context in which it is inserted: method or class modification.
%BEGIN_ALLOW_THREADS
Replaced by a thread state saving procedure. Must match with a %END_ALLOW_THREADS variable.
%END_ALLOW_THREADS
Replaced by a thread state restoring procedure. Must match with a %BEGIN_ALLOW_THREADS variable.
%RETURN_TYPE
Replaced by the type returned by a function or method.
%TYPE
Replaced by the name of the class to which a function belongs. May be used in code injected at method or class level.
Example¶
Just to illustrate the usage of the variables described in the previous
sections, below is an excerpt from the type system description of a Shiboken
test. It changes a method that received argc/argv
arguments into something
that expects a Python sequence instead.
<modify-function signature="overloadedMethod(int, char**)"> <modify-argument index="1"> <replace-type modified-type="PySequence" /> </modify-argument> <modify-argument index="2"> <remove-argument /> </modify-argument> <inject-code class="target" position="beginning"> int argc; char** argv; if (!PySequence_to_argc_argv(%PYARG_1, &argc, &argv)) { PyErr_SetString(PyExc_TypeError, "error"); return 0; } %RETURN_TYPE foo = %CPPSELF.%FUNCTION_NAME(argc, argv); %0 = %CONVERTTOPYTHON[%RETURN_TYPE](foo); for (int i = 0; i < argc; ++i) delete[] argv[i]; delete[] argv; </inject-code> </modify-function>
© 2022 The Qt Company Ltd. Documentation contributions included herein are the copyrights of their respective owners. The documentation provided herein is licensed under the terms of the GNU Free Documentation License version 1.3 as published by the Free Software Foundation. Qt and respective logos are trademarks of The Qt Company Ltd. in Finland and/or other countries worldwide. All other trademarks are property of their respective owners.