setCppPointer and getCppPointer moved to namespace Shiboken::Wrapper

3 files changed, 41 insertions, 39 deletions

diff --git a/libshiboken/basewrapper.cpp b/libshiboken/basewrapper.cpp
index 199387be1..255bee329 100644
--- a/libshiboken/basewrapper.cpp
+++ b/libshiboken/basewrapper.cpp
@@ -333,30 +333,6 @@ PyObject* SbkBaseWrapper_TpNew(PyTypeObject* subtype, PyObject*, PyObject*)
     return reinterpret_cast<PyObject*>(self);
 }
 
-void* getCppPointer(PyObject* wrapper, PyTypeObject* desiredType)
-{
-    PyTypeObject* type = wrapper->ob_type;
-    int idx = 0;
-    if (reinterpret_cast<SbkBaseWrapperType*>(type)->is_multicpp)
-        idx = getTypeIndexOnHierarchy(type, desiredType);
-    return reinterpret_cast<SbkObject*>(wrapper)->d->cptr[idx];
-}
-
-bool setCppPointer(SbkObject* wrapper, PyTypeObject* desiredType, void* cptr)
-{
-    int idx = 0;
-    if (reinterpret_cast<SbkBaseWrapperType*>(wrapper->ob_type)->is_multicpp)
-        idx = getTypeIndexOnHierarchy(wrapper->ob_type, desiredType);
-
-    bool alreadyInitialized = wrapper->d->cptr[idx];
-    if (alreadyInitialized)
-        PyErr_SetString(PyExc_RuntimeError, "You can't initialize an object twice!");
-    else
-        wrapper->d->cptr[idx] = cptr;
-
-    return !alreadyInitialized;
-}
-
 bool cppObjectIsInvalid(PyObject* wrapper)
 {
     if (!wrapper || wrapper == Py_None
@@ -727,6 +703,32 @@ void releaseOwnership(PyObject* pyObj)
     setSequenceOwnership(pyObj, false);
 }
 
+void* cppPointer(PyObject* pyObj, PyTypeObject* desiredType)
+{
+    assert(isShibokenType(pyObj));
+    PyTypeObject* type = pyObj->ob_type;
+    int idx = 0;
+    if (reinterpret_cast<SbkBaseWrapperType*>(type)->is_multicpp)
+        idx = getTypeIndexOnHierarchy(type, desiredType);
+    return reinterpret_cast<SbkObject*>(pyObj)->d->cptr[idx];
+}
+
+bool setCppPointer(SbkObject* sbkObj, PyTypeObject* desiredType, void* cptr)
+{
+    int idx = 0;
+    if (reinterpret_cast<SbkBaseWrapperType*>(sbkObj->ob_type)->is_multicpp)
+        idx = getTypeIndexOnHierarchy(sbkObj->ob_type, desiredType);
+
+    bool alreadyInitialized = sbkObj->d->cptr[idx];
+    if (alreadyInitialized)
+        PyErr_SetString(PyExc_RuntimeError, "You can't initialize an object twice!");
+    else
+        sbkObj->d->cptr[idx] = cptr;
+
+    return !alreadyInitialized;
+}
+
+
 } // namespace Wrapper
 
 } // namespace Shiboken
diff --git a/libshiboken/basewrapper.h b/libshiboken/basewrapper.h
index 1393e1a25..bb76f7ba8 100644
--- a/libshiboken/basewrapper.h
+++ b/libshiboken/basewrapper.h
@@ -146,16 +146,6 @@ inline bool isUserType(PyObject*& pyObj)
 }
 
 /**
-*   Get the C++ pointer of type \p desiredType from a Python object.
-*/
-LIBSHIBOKEN_API void* getCppPointer(PyObject* wrapper, PyTypeObject* desiredType);
-
-/**
-*   Set the C++ pointer of type \p desiredType of a Python object.
-*/
-LIBSHIBOKEN_API bool setCppPointer(SbkObject* wrapper, PyTypeObject* desiredType, void* cptr);
-
-/**
  *   Get/Set Userdata in type class
  */
 LIBSHIBOKEN_API void setTypeUserData(SbkObject* wrapper, void* user_data, DeleteUserDataFunc d_func);
@@ -227,6 +217,16 @@ LIBSHIBOKEN_API void getOwnership(SbkObject* pyObj);
 LIBSHIBOKEN_API void releaseOwnership(PyObject* pyObj);
 LIBSHIBOKEN_API void releaseOwnership(SbkObject* pyObj);
 
+/**
+ *   Get the C++ pointer of type \p desiredType from a Python object.
+ */
+LIBSHIBOKEN_API void* cppPointer(PyObject* pyObj, PyTypeObject* desiredType);
+
+/**
+ *   Set the C++ pointer of type \p desiredType of a Python object.
+ */
+LIBSHIBOKEN_API bool setCppPointer(SbkObject* sbkObj, PyTypeObject* desiredType, void* cptr);
+
 } // namespace Wrapper
 
 } // namespace Shiboken
diff --git a/libshiboken/conversions.h b/libshiboken/conversions.h
index e443dad17..4cead3439 100644
--- a/libshiboken/conversions.h
+++ b/libshiboken/conversions.h
@@ -150,7 +150,7 @@ struct Converter<T*>
     static T* toCpp(PyObject* pyobj)
     {
         if (Shiboken_TypeCheck(pyobj, T))
-            return (T*) getCppPointer(pyobj, SbkType<T>());
+            return (T*) Wrapper::cppPointer(pyobj, SbkType<T>());
 
         else if (Converter<T>::isConvertible(pyobj))
             return CppObjectCopier<T>::copy(Converter<T>::toCpp(pyobj));
@@ -243,7 +243,7 @@ struct ValueTypeConverter
             }
             assert(false);
         }
-        return *reinterpret_cast<T*>(getCppPointer(pyobj, SbkType<T>()));
+        return *reinterpret_cast<T*>(Wrapper::cppPointer(pyobj, SbkType<T>()));
     }
 };
 
@@ -277,8 +277,8 @@ struct ObjectTypeConverter
             return 0;
         SbkBaseWrapperType* shiboType = reinterpret_cast<SbkBaseWrapperType*>(pyobj->ob_type);
         if (shiboType->mi_specialcast)
-            return (T*) shiboType->mi_specialcast(getCppPointer(pyobj, SbkType<T>()), reinterpret_cast<SbkBaseWrapperType*>(SbkType<T>()));
-        return (T*) getCppPointer(pyobj, SbkType<T>());
+            return (T*) shiboType->mi_specialcast(Wrapper::cppPointer(pyobj, SbkType<T>()), reinterpret_cast<SbkBaseWrapperType*>(SbkType<T>()));
+        return (T*) Wrapper::cppPointer(pyobj, SbkType<T>());
     }
 };
 
@@ -587,7 +587,7 @@ struct StdListConverter
     static StdList toCpp(PyObject* pyobj)
     {
         if (PyObject_TypeCheck(pyobj, SbkType<StdList>()))
-            return *reinterpret_cast<StdList*>(getCppPointer(pyobj, SbkType<StdList>()));
+            return *reinterpret_cast<StdList*>(Wrapper::cppPointer(pyobj, SbkType<StdList>()));
 
         StdList result;
         for (int i = 0; i < PySequence_Size(pyobj); i++) {