libshiboken: Take const SbkConverter/SbkObjectType * where appropriate

Change-Id: I0597f4c4f2eb0e8d4979690eeb1f17d78cf4e619
Reviewed-by: Christian Tismer <tismer@stackless.com>

4 files changed, 60 insertions, 53 deletions

diff --git a/libshiboken/basewrapper.cpp b/libshiboken/basewrapper.cpp
index d82297d89..b3f99a8a5 100644
--- a/libshiboken/basewrapper.cpp
+++ b/libshiboken/basewrapper.cpp
@@ -1105,8 +1105,8 @@ bool isValid(PyObject* pyObj, bool throwPyError)
     return isValid(reinterpret_cast<SbkObject*>(pyObj), throwPyError);
 }
 
-SbkObject *findColocatedChild(SbkObject* wrapper,
-                              SbkObjectType* instanceType)
+SbkObject *findColocatedChild(SbkObject *wrapper,
+                              const SbkObjectType *instanceType)
 {
     // Degenerate case, wrapper is the correct wrapper.
     if (reinterpret_cast<const void *>(Py_TYPE(wrapper)) == reinterpret_cast<const void *>(instanceType))
diff --git a/libshiboken/basewrapper.h b/libshiboken/basewrapper.h
index 340419851..002337f3c 100644
--- a/libshiboken/basewrapper.h
+++ b/libshiboken/basewrapper.h
@@ -254,8 +254,8 @@ LIBSHIBOKEN_API Py_hash_t   hash(PyObject* pyObj);
 /**
  * Find a child of given wrapper having same address having the specified type.
  */
-LIBSHIBOKEN_API SbkObject *findColocatedChild(SbkObject* wrapper,
-                                              SbkObjectType* instanceType);
+LIBSHIBOKEN_API SbkObject *findColocatedChild(SbkObject *wrapper,
+                                              const SbkObjectType *instanceType);
 
 /**
  *  Bind a C++ object to Python.
diff --git a/libshiboken/sbkconverter.cpp b/libshiboken/sbkconverter.cpp
index 17af66e22..e7e9995b4 100644
--- a/libshiboken/sbkconverter.cpp
+++ b/libshiboken/sbkconverter.cpp
@@ -169,12 +169,12 @@ void addPythonToCppValueConversion(SbkObjectType* type,
     addPythonToCppValueConversion(type->d->converter, pythonToCppFunc, isConvertibleToCppFunc);
 }
 
-PyObject* pointerToPython(SbkObjectType* type, const void* cppIn)
+PyObject* pointerToPython(const SbkObjectType *type, const void *cppIn)
 {
     return pointerToPython(type->d->converter, cppIn);
 }
 
-PyObject* pointerToPython(SbkConverter* converter, const void* cppIn)
+PyObject* pointerToPython(const SbkConverter *converter, const void *cppIn)
 {
     assert(converter);
     if (!cppIn)
@@ -187,12 +187,12 @@ PyObject* pointerToPython(SbkConverter* converter, const void* cppIn)
     return converter->pointerToPython(cppIn);
 }
 
-PyObject* referenceToPython(SbkObjectType* type, const void* cppIn)
+PyObject* referenceToPython(const SbkObjectType *type, const void *cppIn)
 {
     return referenceToPython(type->d->converter, cppIn);
 }
 
-PyObject* referenceToPython(SbkConverter* converter, const void* cppIn)
+PyObject* referenceToPython(const SbkConverter *converter, const void *cppIn)
 {
     assert(cppIn);
 
@@ -209,7 +209,7 @@ PyObject* referenceToPython(SbkConverter* converter, const void* cppIn)
     return converter->pointerToPython(cppIn);
 }
 
-static inline PyObject* CopyCppToPython(SbkConverter* converter, const void* cppIn)
+static inline PyObject* CopyCppToPython(const SbkConverter *converter, const void *cppIn)
 {
     if (!cppIn)
         Py_RETURN_NONE;
@@ -220,42 +220,42 @@ static inline PyObject* CopyCppToPython(SbkConverter* converter, const void* cpp
     }
     return converter->copyToPython(cppIn);
 }
-PyObject* copyToPython(SbkObjectType* type, const void* cppIn)
+PyObject* copyToPython(const SbkObjectType *type, const void *cppIn)
 {
     return CopyCppToPython(type->d->converter, cppIn);
 }
-PyObject* copyToPython(SbkConverter* converter, const void* cppIn)
+PyObject* copyToPython(const SbkConverter *converter, const void *cppIn)
 {
     return CopyCppToPython(converter, cppIn);
 }
 
-PythonToCppFunc isPythonToCppPointerConvertible(SbkObjectType* type, PyObject* pyIn)
+PythonToCppFunc isPythonToCppPointerConvertible(const 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(const SbkConverter *converter, PyObject *pyIn)
 {
     assert(pyIn);
-    ToCppConversionList& convs = converter->toCppConversions;
-    for (ToCppConversionList::iterator conv = convs.begin(); conv != convs.end(); ++conv) {
+    const ToCppConversionList& convs = converter->toCppConversions;
+    for (ToCppConversionList::const_iterator conv = convs.begin(), end = convs.end(); conv != end; ++conv) {
         PythonToCppFunc toCppFunc = 0;
         if ((toCppFunc = (*conv).first(pyIn)))
             return toCppFunc;
     }
     return 0;
 }
-PythonToCppFunc isPythonToCppValueConvertible(SbkObjectType* type, PyObject* pyIn)
+PythonToCppFunc isPythonToCppValueConvertible(const SbkObjectType *type, PyObject *pyIn)
 {
     return IsPythonToCppConvertible(type->d->converter, pyIn);
 }
-PythonToCppFunc isPythonToCppConvertible(SbkConverter* converter, PyObject* pyIn)
+PythonToCppFunc isPythonToCppConvertible(const SbkConverter *converter, PyObject *pyIn)
 {
     return IsPythonToCppConvertible(converter, pyIn);
 }
 
-PythonToCppFunc isPythonToCppReferenceConvertible(SbkObjectType* type, PyObject* pyIn)
+PythonToCppFunc isPythonToCppReferenceConvertible(const SbkObjectType *type, PyObject *pyIn)
 {
     if (pyIn != Py_None) {
         PythonToCppFunc toCpp = isPythonToCppPointerConvertible(type, pyIn);
@@ -292,7 +292,7 @@ void pythonToCppPointer(SbkObjectType* type, PyObject* pyIn, void* cppOut)
         : cppPointer(reinterpret_cast<PyTypeObject *>(type), reinterpret_cast<SbkObject *>(pyIn));
 }
 
-void pythonToCppPointer(SbkConverter* converter, PyObject* pyIn, void* cppOut)
+void pythonToCppPointer(const SbkConverter *converter, PyObject *pyIn, void *cppOut)
 {
     assert(converter);
     assert(pyIn);
@@ -302,7 +302,7 @@ void pythonToCppPointer(SbkConverter* converter, PyObject* pyIn, void* cppOut)
         : cppPointer(reinterpret_cast<PyTypeObject *>(converter->pythonType), reinterpret_cast<SbkObject *>(pyIn));
 }
 
-static void _pythonToCppCopy(SbkConverter* converter, PyObject* pyIn, void* cppOut)
+static void _pythonToCppCopy(const SbkConverter *converter, PyObject *pyIn, void *cppOut)
 {
     assert(converter);
     assert(pyIn);
@@ -312,18 +312,18 @@ static void _pythonToCppCopy(SbkConverter* converter, PyObject* pyIn, void* cppO
         toCpp(pyIn, cppOut);
 }
 
-void pythonToCppCopy(SbkObjectType* type, PyObject* pyIn, void* cppOut)
+void pythonToCppCopy(const SbkObjectType *type, PyObject *pyIn, void *cppOut)
 {
     assert(type);
     _pythonToCppCopy(type->d->converter, pyIn, cppOut);
 }
 
-void pythonToCppCopy(SbkConverter* converter, PyObject* pyIn, void* cppOut)
+void pythonToCppCopy(const SbkConverter *converter, PyObject *pyIn, void *cppOut)
 {
     _pythonToCppCopy(converter, pyIn, cppOut);
 }
 
-bool isImplicitConversion(SbkObjectType* type, PythonToCppFunc toCppFunc)
+bool isImplicitConversion(const SbkObjectType *type, PythonToCppFunc toCppFunc)
 {
     // This is the Object Type or Value Type conversion that only
     // retrieves the C++ pointer held in the Python wrapper.
@@ -381,7 +381,7 @@ bool checkSequenceTypes(PyTypeObject* type, PyObject* pyIn)
     }
     return true;
 }
-bool convertibleSequenceTypes(SbkConverter* converter, PyObject* pyIn)
+bool convertibleSequenceTypes(const SbkConverter *converter, PyObject *pyIn)
 {
     assert(converter);
     assert(pyIn);
@@ -394,7 +394,7 @@ bool convertibleSequenceTypes(SbkConverter* converter, PyObject* pyIn)
     }
     return true;
 }
-bool convertibleSequenceTypes(SbkObjectType* type, PyObject* pyIn)
+bool convertibleSequenceTypes(const SbkObjectType *type, PyObject *pyIn)
 {
     assert(type);
     return convertibleSequenceTypes(type->d->converter, pyIn);
@@ -415,7 +415,9 @@ bool checkPairTypes(PyTypeObject* firstType, PyTypeObject* secondType, PyObject*
         return false;
     return true;
 }
-bool convertiblePairTypes(SbkConverter* firstConverter, bool firstCheckExact, SbkConverter* secondConverter, bool secondCheckExact, PyObject* pyIn)
+bool convertiblePairTypes(const SbkConverter *firstConverter, bool firstCheckExact,
+                          const SbkConverter *secondConverter, bool secondCheckExact,
+                          PyObject *pyIn)
 {
     assert(firstConverter);
     assert(secondConverter);
@@ -462,7 +464,8 @@ bool checkDictTypes(PyTypeObject* keyType, PyTypeObject* valueType, PyObject* py
     return true;
 }
 
-bool convertibleDictTypes(SbkConverter* keyConverter, bool keyCheckExact, SbkConverter* valueConverter, bool valueCheckExact, PyObject* pyIn)
+bool convertibleDictTypes(const SbkConverter * keyConverter, bool keyCheckExact, const SbkConverter *valueConverter,
+                          bool valueCheckExact, PyObject *pyIn)
 {
     assert(keyConverter);
     assert(valueConverter);
@@ -489,7 +492,7 @@ bool convertibleDictTypes(SbkConverter* keyConverter, bool keyCheckExact, SbkCon
     return true;
 }
 
-PyTypeObject* getPythonTypeObject(SbkConverter* converter)
+PyTypeObject* getPythonTypeObject(const SbkConverter *converter)
 {
     if (converter)
         return converter->pythonType;
@@ -501,18 +504,18 @@ PyTypeObject* getPythonTypeObject(const char* typeName)
     return getPythonTypeObject(getConverter(typeName));
 }
 
-bool pythonTypeIsValueType(SbkConverter* converter)
+bool pythonTypeIsValueType(const SbkConverter *converter)
 {
     assert(converter);
     return converter->pointerToPython && converter->copyToPython;
 }
 
-bool pythonTypeIsObjectType(SbkConverter* converter)
+bool pythonTypeIsObjectType(const SbkConverter *converter)
 {
     return converter->pointerToPython && !converter->copyToPython;
 }
 
-bool pythonTypeIsWrapperType(SbkConverter* converter)
+bool pythonTypeIsWrapperType(const SbkConverter *converter)
 {
     return converter->pointerToPython;
 }
diff --git a/libshiboken/sbkconverter.h b/libshiboken/sbkconverter.h
index 9308013f0..7489b930d 100644
--- a/libshiboken/sbkconverter.h
+++ b/libshiboken/sbkconverter.h
@@ -190,8 +190,8 @@ LIBSHIBOKEN_API void addPythonToCppValueConversion(SbkObjectType* type,
  *      TYPE* var;
  *      PyObject* pyVar = pointerToPython(SBKTYPE, &var);
  */
-LIBSHIBOKEN_API PyObject* pointerToPython(SbkObjectType* type, const void* cppIn);
-LIBSHIBOKEN_API PyObject* pointerToPython(SbkConverter* converter, const void* cppIn);
+LIBSHIBOKEN_API PyObject* pointerToPython(const SbkObjectType *type, const void *cppIn);
+LIBSHIBOKEN_API PyObject* pointerToPython(const SbkConverter *converter, const void *cppIn);
 
 /**
  *  For the given \p cppIn C++ reference it returns the Python wrapper object,
@@ -202,8 +202,8 @@ LIBSHIBOKEN_API PyObject* pointerToPython(SbkConverter* converter, const void* c
  *      TYPE& var = SOMETHING;
  *      PyObject* pyVar = referenceToPython(SBKTYPE, &var);
  */
-LIBSHIBOKEN_API PyObject* referenceToPython(SbkObjectType* type, const void* cppIn);
-LIBSHIBOKEN_API PyObject* referenceToPython(SbkConverter* converter, const void* cppIn);
+LIBSHIBOKEN_API PyObject* referenceToPython(const SbkObjectType *type, const void *cppIn);
+LIBSHIBOKEN_API PyObject* referenceToPython(const SbkConverter *converter, const void *cppIn);
 
 /**
  *  Retrieves the Python wrapper object for the given C++ value pointed by \p cppIn.
@@ -212,8 +212,8 @@ LIBSHIBOKEN_API PyObject* referenceToPython(SbkConverter* converter, const void*
  *      TYPE var;
  *      PyObject* pyVar = copyToPython(SBKTYPE, &var);
  */
-LIBSHIBOKEN_API PyObject* copyToPython(SbkObjectType* type, const void* cppIn);
-LIBSHIBOKEN_API PyObject* copyToPython(SbkConverter* converter, const void* cppIn);
+LIBSHIBOKEN_API PyObject* copyToPython(const SbkObjectType *type, const void *cppIn);
+LIBSHIBOKEN_API PyObject* copyToPython(const SbkConverter *converter, const void *cppIn);
 
 // Python -> C++ ---------------------------------------------------------------------------
 
@@ -221,7 +221,7 @@ LIBSHIBOKEN_API PyObject* copyToPython(SbkConverter* converter, const void* cppI
  *  Returns a Python to C++ conversion function if the Python object is convertible to a C++ pointer.
  *  It returns NULL if the Python object is not convertible to \p type.
  */
-LIBSHIBOKEN_API PythonToCppFunc isPythonToCppPointerConvertible(SbkObjectType* type, PyObject* pyIn);
+LIBSHIBOKEN_API PythonToCppFunc isPythonToCppPointerConvertible(const SbkObjectType *type, PyObject *pyIn);
 
 /**
  *  Returns a Python to C++ conversion function if the Python object is convertible to a C++ value.
@@ -229,7 +229,7 @@ LIBSHIBOKEN_API PythonToCppFunc isPythonToCppPointerConvertible(SbkObjectType* t
  *  convert the object to the expected \p type.
  *  It returns NULL if the Python object is not convertible to \p type.
  */
-LIBSHIBOKEN_API PythonToCppFunc isPythonToCppValueConvertible(SbkObjectType* type, PyObject* pyIn);
+LIBSHIBOKEN_API PythonToCppFunc isPythonToCppValueConvertible(const SbkObjectType *type, PyObject *pyIn);
 
 /**
  *  Returns a Python to C++ conversion function if the Python object is convertible to a C++ reference.
@@ -237,10 +237,10 @@ LIBSHIBOKEN_API PythonToCppFunc isPythonToCppValueConvertible(SbkObjectType* typ
  *  or a new C++ value if it must be a implicit conversion.
  *  It returns NULL if the Python object is not convertible to \p type.
  */
-LIBSHIBOKEN_API PythonToCppFunc isPythonToCppReferenceConvertible(SbkObjectType* type, PyObject* pyIn);
+LIBSHIBOKEN_API PythonToCppFunc isPythonToCppReferenceConvertible(const SbkObjectType *type, PyObject *pyIn);
 
 /// This is the same as isPythonToCppValueConvertible function.
-LIBSHIBOKEN_API PythonToCppFunc isPythonToCppConvertible(SbkConverter* converter, PyObject* pyIn);
+LIBSHIBOKEN_API PythonToCppFunc isPythonToCppConvertible(const SbkConverter *converter, PyObject *pyIn);
 
 /**
  *  Returns the C++ pointer for the \p pyIn object cast to the type passed via \p desiredType.
@@ -251,11 +251,11 @@ LIBSHIBOKEN_API void* cppPointer(PyTypeObject* desiredType, SbkObject* pyIn);
 
 /// Converts a Python object \p pyIn to C++ and stores the result in the C++ pointer passed in \p cppOut.
 LIBSHIBOKEN_API void pythonToCppPointer(SbkObjectType* type, PyObject* pyIn, void* cppOut);
-LIBSHIBOKEN_API void pythonToCppPointer(SbkConverter* converter, PyObject* pyIn, void* cppOut);
+LIBSHIBOKEN_API void pythonToCppPointer(const SbkConverter *converter, PyObject *pyIn, void *cppOut);
 
 /// Converts a Python object \p pyIn to C++, and copies the result in the C++ variable passed in \p cppOut.
-LIBSHIBOKEN_API void pythonToCppCopy(SbkObjectType* type, PyObject* pyIn, void* cppOut);
-LIBSHIBOKEN_API void pythonToCppCopy(SbkConverter* converter, PyObject* pyIn, void* cppOut);
+LIBSHIBOKEN_API void pythonToCppCopy(const SbkObjectType *type, PyObject *pyIn, void *cppOut);
+LIBSHIBOKEN_API void pythonToCppCopy(const SbkConverter *converter, PyObject *pyIn, void *cppOut);
 
 /**
  *  Helper function returned by generated convertible checking functions
@@ -268,7 +268,7 @@ LIBSHIBOKEN_API void nonePythonToCppNullPtr(PyObject*, void* cppOut);
  *  It is used when C++ expects a reference argument, so it may be the same object received
  *  from Python, or another created through implicit conversion.
  */
-LIBSHIBOKEN_API bool isImplicitConversion(SbkObjectType* type, PythonToCppFunc toCpp);
+LIBSHIBOKEN_API bool isImplicitConversion(const SbkObjectType *type, PythonToCppFunc toCpp);
 
 /// Registers a converter with a type name that may be used to retrieve the converter.
 LIBSHIBOKEN_API void registerConverterName(SbkConverter* converter, const char* typeName);
@@ -283,37 +283,41 @@ LIBSHIBOKEN_API SbkConverter* primitiveTypeConverter(int index);
 LIBSHIBOKEN_API bool checkSequenceTypes(PyTypeObject* type, PyObject* pyIn);
 
 /// Returns true if a Python sequence is comprised of objects of a type convertible to the one represented by the given \p converter.
-LIBSHIBOKEN_API bool convertibleSequenceTypes(SbkConverter* converter, PyObject* pyIn);
+LIBSHIBOKEN_API bool convertibleSequenceTypes(const SbkConverter *converter, PyObject *pyIn);
 
 /// Returns true if a Python sequence is comprised of objects of a type convertible to \p type.
-LIBSHIBOKEN_API bool convertibleSequenceTypes(SbkObjectType* type, PyObject* pyIn);
+LIBSHIBOKEN_API bool convertibleSequenceTypes(const SbkObjectType *type, PyObject *pyIn);
 
 /// Returns true if a Python sequence can be converted to a C++ pair.
 LIBSHIBOKEN_API bool checkPairTypes(PyTypeObject* firstType, PyTypeObject* secondType, PyObject* pyIn);
 
 /// Returns true if a Python sequence can be converted to a C++ pair.
-LIBSHIBOKEN_API bool convertiblePairTypes(SbkConverter* firstConverter, bool firstCheckExact, SbkConverter* secondConverter, bool secondCheckExact, PyObject* pyIn);
+LIBSHIBOKEN_API bool convertiblePairTypes(const SbkConverter *firstConverter, bool firstCheckExact,
+                                          const SbkConverter *secondConverter, bool secondCheckExact,
+                                          PyObject *pyIn);
 
 /// Returns true if a Python dictionary can be converted to a C++ hash or map.
 LIBSHIBOKEN_API bool checkDictTypes(PyTypeObject* keyType, PyTypeObject* valueType, PyObject* pyIn);
 
 /// Returns true if a Python dictionary can be converted to a C++ hash or map.
-LIBSHIBOKEN_API bool convertibleDictTypes(SbkConverter* keyConverter, bool keyCheckExact, SbkConverter* valueConverter, bool valueCheckExact, PyObject* pyIn);
+LIBSHIBOKEN_API bool convertibleDictTypes(const SbkConverter *keyConverter, bool keyCheckExact,
+                                          const SbkConverter *valueConverter, bool valueCheckExact,
+                                          PyObject *pyIn);
 
 /// Returns the Python type object associated with the given \p converter.
-LIBSHIBOKEN_API PyTypeObject* getPythonTypeObject(SbkConverter* converter);
+LIBSHIBOKEN_API PyTypeObject* getPythonTypeObject(const SbkConverter *converter);
 
 /// Returns the Python type object for the given \p typeName.
 LIBSHIBOKEN_API PyTypeObject* getPythonTypeObject(const char* typeName);
 
 /// Returns true if the Python type associated with the converter is a value type.
-LIBSHIBOKEN_API bool pythonTypeIsValueType(SbkConverter* converter);
+LIBSHIBOKEN_API bool pythonTypeIsValueType(const SbkConverter *converter);
 
 /// Returns true if the Python type associated with the converter is an object type.
-LIBSHIBOKEN_API bool pythonTypeIsObjectType(SbkConverter* converter);
+LIBSHIBOKEN_API bool pythonTypeIsObjectType(const SbkConverter *converter);
 
 /// Returns true if the Python type associated with the converter is a wrapper type.
-LIBSHIBOKEN_API bool pythonTypeIsWrapperType(SbkConverter* converter);
+LIBSHIBOKEN_API bool pythonTypeIsWrapperType(const SbkConverter *converter);
 
 #define SBK_PY_LONG_LONG_IDX            0
 // Qt5: name collision in QtCore after QBool is replaced by bool