diff options
Diffstat (limited to 'sources/shiboken2/libshiboken/tmp-referencetopython')
-rw-r--r-- | sources/shiboken2/libshiboken/tmp-referencetopython/sbkconverter.cpp | 59 | ||||
-rw-r--r-- | sources/shiboken2/libshiboken/tmp-referencetopython/sbkconverter.h | 46 |
2 files changed, 54 insertions, 51 deletions
diff --git a/sources/shiboken2/libshiboken/tmp-referencetopython/sbkconverter.cpp b/sources/shiboken2/libshiboken/tmp-referencetopython/sbkconverter.cpp index 8e351cedd..ab205e215 100644 --- a/sources/shiboken2/libshiboken/tmp-referencetopython/sbkconverter.cpp +++ b/sources/shiboken2/libshiboken/tmp-referencetopython/sbkconverter.cpp @@ -46,13 +46,13 @@ namespace Shiboken { namespace Conversions { -static SbkConverter* createConverterObject(PyTypeObject* type, +static SbkConverter *createConverterObject(PyTypeObject *type, PythonToCppFunc toCppPointerConvFunc, IsConvertibleToCppFunc toCppPointerCheckFunc, CppToPythonFunc pointerToPythonFunc, CppToPythonFunc copyToPythonFunc) { - SbkConverter* converter = new SbkConverter; + SbkConverter *converter = new SbkConverter; converter->pythonType = type; converter->pointerToPython = pointerToPythonFunc; @@ -64,20 +64,20 @@ static SbkConverter* createConverterObject(PyTypeObject* type, return converter; } -SbkConverter* createConverter(SbkObjectType* type, +SbkConverter *createConverter(SbkObjectType *type, PythonToCppFunc toCppPointerConvFunc, IsConvertibleToCppFunc toCppPointerCheckFunc, CppToPythonFunc pointerToPythonFunc, CppToPythonFunc copyToPythonFunc) { - SbkConverter* converter = createConverterObject((PyTypeObject*)type, + SbkConverter *converter = createConverterObject(reinterpret_cast<PyTypeObject *>(type), toCppPointerConvFunc, toCppPointerCheckFunc, pointerToPythonFunc, copyToPythonFunc); type->d->converter = converter; return converter; } -void deleteConverter(SbkConverter* converter) +void deleteConverter(SbkConverter *converter) { if (converter) { converter->toCppConversions.clear(); @@ -85,44 +85,44 @@ void deleteConverter(SbkConverter* converter) } } -void addPythonToCppValueConversion(SbkConverter* converter, +void addPythonToCppValueConversion(SbkConverter *converter, PythonToCppFunc pythonToCppFunc, IsConvertibleToCppFunc isConvertibleToCppFunc) { converter->toCppConversions.push_back(std::make_pair(isConvertibleToCppFunc, pythonToCppFunc)); } -void addPythonToCppValueConversion(SbkObjectType* type, +void addPythonToCppValueConversion(SbkObjectType *type, PythonToCppFunc pythonToCppFunc, IsConvertibleToCppFunc isConvertibleToCppFunc) { addPythonToCppValueConversion(type->d->converter, pythonToCppFunc, isConvertibleToCppFunc); } -PyObject* pointerToPython(SbkObjectType* type, const void* cppIn) +PyObject *pointerToPython(SbkObjectType *type, const void *cppIn) { if (!cppIn) Py_RETURN_NONE; return type->d->converter->pointerToPython(cppIn); } -static inline PyObject* CopyCppToPython(SbkConverter* converter, const void* cppIn) +static inline PyObject *CopyCppToPython(SbkConverter *converter, const void *cppIn) { assert(cppIn); return converter->copyToPython(cppIn); } -PyObject* copyToPython(SbkObjectType* type, const void* cppIn) +PyObject *copyToPython(SbkObjectType *type, const void *cppIn) { return CopyCppToPython(type->d->converter, cppIn); } -PyObject* toPython(SbkConverter* converter, const void* cppIn) +PyObject *toPython(SbkConverter *converter, const void *cppIn) { return CopyCppToPython(converter, cppIn); } -PyObject* referenceToPython(SbkObjectType* type, const void* cppIn) +PyObject *referenceToPython(SbkObjectType *type, const void *cppIn) { assert(cppIn); - PyObject* pyOut = (PyObject*)BindingManager::instance().retrieveWrapper(cppIn); + PyObject *pyOut = (PyObject *)BindingManager::instance().retrieveWrapper(cppIn); if (pyOut) { Py_INCREF(pyOut); return pyOut; @@ -134,16 +134,16 @@ PyObject* referenceToPython(SbkObjectType* type, const void* cppIn) return type->d->converter->pointerToPython(cppIn); } -PythonToCppFunc isPythonToCppPointerConvertible(SbkObjectType* type, PyObject* pyIn) +PythonToCppFunc isPythonToCppPointerConvertible(SbkObjectType *type, PyObject *pyIn) { assert(pyIn); return type->d->converter->toCppPointerConversion.first(pyIn); } -static inline PythonToCppFunc IsPythonToCppConvertible(SbkConverter* converter, PyObject* pyIn) +static inline PythonToCppFunc IsPythonToCppConvertible(SbkConverter *converter, PyObject *pyIn) { assert(pyIn); - ToCppConversionList& convs = converter->toCppConversions; + ToCppConversionList &convs = converter->toCppConversions; for (ToCppConversionList::iterator conv = convs.begin(); conv != convs.end(); ++conv) { PythonToCppFunc toCppFunc = 0; if ((toCppFunc = (*conv).first(pyIn))) @@ -151,16 +151,16 @@ static inline PythonToCppFunc IsPythonToCppConvertible(SbkConverter* converter, } return 0; } -PythonToCppFunc isPythonToCppValueConvertible(SbkObjectType* type, PyObject* pyIn) +PythonToCppFunc isPythonToCppValueConvertible(SbkObjectType *type, PyObject *pyIn) { return IsPythonToCppConvertible(type->d->converter, pyIn); } -PythonToCppFunc isPythonToCppConvertible(SbkConverter* converter, PyObject* pyIn) +PythonToCppFunc isPythonToCppConvertible(SbkConverter *converter, PyObject *pyIn) { return IsPythonToCppConvertible(converter, pyIn); } -PythonToCppFunc isPythonToCppReferenceConvertible(SbkObjectType* type, PyObject* pyIn) +PythonToCppFunc isPythonToCppReferenceConvertible(SbkObjectType *type, PyObject *pyIn) { if (pyIn != Py_None) { PythonToCppFunc toCpp = isPythonToCppPointerConvertible(type, pyIn); @@ -170,24 +170,27 @@ PythonToCppFunc isPythonToCppReferenceConvertible(SbkObjectType* type, PyObject* return isPythonToCppValueConvertible(type, pyIn); } -void nonePythonToCppNullPtr(PyObject*, void* cppOut) +void nonePythonToCppNullPtr(PyObject *, void *cppOut) { assert(cppOut); - *((void**)cppOut) = 0; + *reinterpret_cast<void **>(cppOut) = nullptr; } -void pythonToCppPointer(SbkObjectType* type, PyObject* pyIn, void* cppOut) +void pythonToCppPointer(SbkObjectType *type, PyObject *pyIn, void *cppOut) { assert(pyIn); assert(cppOut); - SbkObjectType* inType = (SbkObjectType*)Py_TYPE(pyIn); - if (ObjectType::hasCast(inType)) - *((void**)cppOut) = ObjectType::cast(inType, (SbkObject*)pyIn, (PyTypeObject*)type); - else - *((void**)cppOut) = Object::cppPointer((SbkObject*)pyIn, (PyTypeObject*)type); + SbkObjectType *inType = (SbkObjectType *)Py_TYPE(pyIn); + if (ObjectType::hasCast(inType)) { + *reinterpret_cast<void **>(cppOut) = + ObjectType::cast(inType, reinterpret_cast<SbkObject *>(pyIn), reinterpret_cast<PyTypeObject *>(type)); + } else { + *reinterpret_cast<void **>(cppOut) = + Object::cppPointer(reinterpret_cast<SbkObject *>(pyIn), reinterpret_cast<PyTypeObject *>(type)); + } } -bool isImplicitConversion(SbkObjectType* type, PythonToCppFunc toCppFunc) +bool isImplicitConversion(SbkObjectType *type, PythonToCppFunc toCppFunc) { // This is the Object Type or Value Type conversion that only // retrieves the C++ pointer held in the Python wrapper. diff --git a/sources/shiboken2/libshiboken/tmp-referencetopython/sbkconverter.h b/sources/shiboken2/libshiboken/tmp-referencetopython/sbkconverter.h index cc9ea7a19..3578e4039 100644 --- a/sources/shiboken2/libshiboken/tmp-referencetopython/sbkconverter.h +++ b/sources/shiboken2/libshiboken/tmp-referencetopython/sbkconverter.h @@ -64,7 +64,7 @@ struct SbkConverter; * * C++ -> Python */ -typedef PyObject* (*CppToPythonFunc)(const void*); +typedef PyObject *(*CppToPythonFunc)(const void *); /** * This function converts a Python object to a C++ value, it may be @@ -77,7 +77,7 @@ typedef PyObject* (*CppToPythonFunc)(const void*); * * Python -> C++ */ -typedef void (*PythonToCppFunc)(PyObject*,void*); +typedef void (*PythonToCppFunc)(PyObject *,void *); /** * Checks if the Python object passed in the argument is convertible to a @@ -88,7 +88,7 @@ typedef void (*PythonToCppFunc)(PyObject*,void*); * * Python -> C++ ? */ -typedef PythonToCppFunc (*IsConvertibleToCppFunc)(PyObject*); +typedef PythonToCppFunc (*IsConvertibleToCppFunc)(PyObject *); } // extern "C" @@ -105,22 +105,22 @@ namespace Conversions { * \param copyToPythonFunc Function to convert a C++ object to a Python \p type, copying the object. * \returns The new converter referred by the wrapper \p type. */ -LIBSHIBOKEN_API SbkConverter* createConverter(SbkObjectType* type, +LIBSHIBOKEN_API SbkConverter *createConverter(SbkObjectType *type, PythonToCppFunc toCppPointerConvFunc, IsConvertibleToCppFunc toCppPointerCheckFunc, CppToPythonFunc pointerToPythonFunc, CppToPythonFunc copyToPythonFunc = 0); -LIBSHIBOKEN_API void deleteConverter(SbkConverter* converter); +LIBSHIBOKEN_API void deleteConverter(SbkConverter *converter); /** * Adds a new conversion of a Python object to a C++ value. * This is used in copy and implicit conversions. */ -LIBSHIBOKEN_API void addPythonToCppValueConversion(SbkConverter* converter, +LIBSHIBOKEN_API void addPythonToCppValueConversion(SbkConverter *converter, PythonToCppFunc pythonToCppFunc, IsConvertibleToCppFunc isConvertibleToCppFunc); -LIBSHIBOKEN_API void addPythonToCppValueConversion(SbkObjectType* type, +LIBSHIBOKEN_API void addPythonToCppValueConversion(SbkObjectType *type, PythonToCppFunc pythonToCppFunc, IsConvertibleToCppFunc isConvertibleToCppFunc); @@ -130,19 +130,19 @@ LIBSHIBOKEN_API void addPythonToCppValueConversion(SbkObjectType* type, * Retrieves the Python wrapper object for the given \p cppIn C++ pointer object. * This function is used only for Value and Object Types. * Example usage: - * TYPE* var; - * PyObject* pyVar = pointerToPython(SBKTYPE, &var); + * TYPE *var; + * PyObject *pyVar = pointerToPython(SBKTYPE, &var); */ -LIBSHIBOKEN_API PyObject* pointerToPython(SbkObjectType* type, const void* cppIn); +LIBSHIBOKEN_API PyObject *pointerToPython(SbkObjectType *type, const void *cppIn); /** * Retrieves the Python wrapper object for the given C++ value pointed by \p cppIn. * This function is used only for Value Types. * Example usage: * TYPE var; - * PyObject* pyVar = copyToPython(SBKTYPE, &var); + * PyObject *pyVar = copyToPython(SBKTYPE, &var); */ -LIBSHIBOKEN_API PyObject* copyToPython(SbkObjectType* type, const void* cppIn); +LIBSHIBOKEN_API PyObject *copyToPython(SbkObjectType *type, const void *cppIn); // TODO:WRITEDOCSTRING - used only for Value Types - cppIn must point to a value /** @@ -150,41 +150,41 @@ LIBSHIBOKEN_API PyObject* copyToPython(SbkObjectType* type, const void* cppIn); * This function is used only for Value and Object Types. * It differs from pointerToPython() for not checking for a NULL pointer. * Example usage: - * TYPE& var = SOMETHING; - * PyObject* pyVar = copyToPython(SBKTYPE, &var); + * TYPE &var = SOMETHING; + * PyObject *pyVar = copyToPython(SBKTYPE, &var); */ -LIBSHIBOKEN_API PyObject* referenceToPython(SbkObjectType* type, const void* cppIn); +LIBSHIBOKEN_API PyObject *referenceToPython(SbkObjectType *type, const void *cppIn); // TODO:WRITEDOCSTRING - used only for Primitives and Containers (and Value Types) - cppIn must point to a primitive, container or value type /// This is the same as copyToPython function. -LIBSHIBOKEN_API PyObject* toPython(SbkConverter* converter, const void* cppIn); +LIBSHIBOKEN_API PyObject *toPython(SbkConverter *converter, const void *cppIn); // Python -> C++ convertibility checks ----------------------------------------------------- // TODO:WRITEDOCSTRING -LIBSHIBOKEN_API PythonToCppFunc isPythonToCppPointerConvertible(SbkObjectType* type, PyObject* pyIn); +LIBSHIBOKEN_API PythonToCppFunc isPythonToCppPointerConvertible(SbkObjectType *type, PyObject *pyIn); // TODO:WRITEDOCSTRING- Returns a Python to C++ conversion function if true, or NULL if false. -LIBSHIBOKEN_API PythonToCppFunc isPythonToCppValueConvertible(SbkObjectType* type, PyObject* pyIn); +LIBSHIBOKEN_API PythonToCppFunc isPythonToCppValueConvertible(SbkObjectType *type, PyObject *pyIn); // TODO:WRITEDOCSTRING- Returns a Python to C++ conversion function if true, or NULL if false. -LIBSHIBOKEN_API PythonToCppFunc isPythonToCppReferenceConvertible(SbkObjectType* type, PyObject* pyIn); +LIBSHIBOKEN_API PythonToCppFunc isPythonToCppReferenceConvertible(SbkObjectType *type, PyObject *pyIn); /// This is the same as isPythonToCppValueConvertible function. -LIBSHIBOKEN_API PythonToCppFunc isPythonToCppConvertible(SbkConverter* converter, PyObject* pyIn); +LIBSHIBOKEN_API PythonToCppFunc isPythonToCppConvertible(SbkConverter *converter, PyObject *pyIn); // Python -> C++ --------------------------------------------------------------------------- // TODO:WRITEDOCSTRING - function used by the generated [TYPE]_PythonToCpp_[TYPE]_PTR -LIBSHIBOKEN_API void pythonToCppPointer(SbkObjectType* type, PyObject* pyIn, void* cppOut); +LIBSHIBOKEN_API void pythonToCppPointer(SbkObjectType *type, PyObject *pyIn, void *cppOut); // TODO:WRITEDOCSTRING - function used by the generated isConvertible when the PyObject is None, // making a C++ NULL pointer the result of the toCpp function call. // DRAFT: When the Python object is a Py_None, it's C++ conversion is always a NULL pointer. -LIBSHIBOKEN_API void nonePythonToCppNullPtr(PyObject*, void* cppOut); +LIBSHIBOKEN_API void nonePythonToCppNullPtr(PyObject *, void *cppOut); // TODO:WRITEDOCSTRING - tells if \p toCpp is an implicit conversion. -LIBSHIBOKEN_API bool isImplicitConversion(SbkObjectType* type, PythonToCppFunc toCpp); +LIBSHIBOKEN_API bool isImplicitConversion(SbkObjectType *type, PythonToCppFunc toCpp); } } // namespace Shiboken::Conversions |