fix #1959

jef · jef · commit 3d35c57d9d84 · 2009-10-08T16:10:36.000Z
git-svn-id: http://svn.osgeo.org/qgis/trunk@11773 c8812cc2-4d05-0410-92ff-de0c093fc19c
diff --git a/python/core/conversions.sip b/python/core/conversions.sip
@@ -79,17 +79,17 @@ template <TYPE>
   for (int i = 0; i < PyList_GET_SIZE(sipPy); ++i)
   {
     int state;
-    //TYPE *t = reinterpret_cast<TYPE *>(sipConvertToInstance(PyList_GET_ITEM(sipPy, i), sipClass_TYPE, sipTransferObj, SIP_NOT_NONE, &state, sipIsErr));
+    //TYPE *t = reinterpret_cast<TYPE *>(sipConvertToInstance(PyList_GET_ITEM(sipPy, i), (sipWrapperType *) sipTypeAsPyTypeObject (sipType_TYPE), sipTransferObj, SIP_NOT_NONE, &state, sipIsErr));
     QVector<TYPE> * t = reinterpret_cast< QVector<TYPE> * >(sipConvertToMappedType(PyList_GET_ITEM(sipPy, i), qvector_qgspoint, sipTransferObj, SIP_NOT_NONE, &state, sipIsErr));
 
     if (*sipIsErr)
     {
-      sipReleaseInstance(t, sipClass_TYPE, state);
+      sipReleaseInstance(t, (sipWrapperType *) sipTypeAsPyTypeObject (sipType_TYPE), state);
       delete ql;
       return 0;
     }
     ql->append(*t);
-    sipReleaseInstance(t, sipClass_TYPE, state);
+    sipReleaseInstance(t, (sipWrapperType *) sipTypeAsPyTypeObject (sipType_TYPE), state);
   }
 
   *sipCppPtr = ql;
@@ -155,17 +155,17 @@ template <TYPE>
   for (int i = 0; i < PyList_GET_SIZE(sipPy); ++i)
   {
     int state;
-    //TYPE *t = reinterpret_cast<TYPE *>(sipConvertToInstance(PyList_GET_ITEM(sipPy, i), sipClass_TYPE, sipTransferObj, SIP_NOT_NONE, &state, sipIsErr));
+    //TYPE *t = reinterpret_cast<TYPE *>(sipConvertToInstance(PyList_GET_ITEM(sipPy, i), (sipWrapperType *) sipTypeAsPyTypeObject (sipType_TYPE), sipTransferObj, SIP_NOT_NONE, &state, sipIsErr));
     QVector<QVector<TYPE> > * t = reinterpret_cast< QVector< QVector<TYPE> > * >(sipConvertToMappedType(PyList_GET_ITEM(sipPy, i), qvector_qgspoint, sipTransferObj, SIP_NOT_NONE, &state, sipIsErr));
 
     if (*sipIsErr)
     {
-      sipReleaseInstance(t, sipClass_TYPE, state);
+      sipReleaseInstance(t, (sipWrapperType *) sipTypeAsPyTypeObject (sipType_TYPE), state);
       delete ql;
       return 0;
     }
     ql->append(*t);
-    sipReleaseInstance(t, sipClass_TYPE, state);
+    sipReleaseInstance(t, (sipWrapperType *) sipTypeAsPyTypeObject (sipType_TYPE), state);
   }
 
   *sipCppPtr = ql;
@@ -245,7 +245,7 @@ template <TYPE>
     TYPE *t = new TYPE(*it);
     PyObject *tobj;
 
-    if ((tobj = sipConvertFromNewInstance(t, sipClass_TYPE, sipTransferObj)) == NULL)
+    if ((tobj = sipConvertFromNewInstance(t, (sipWrapperType *) sipTypeAsPyTypeObject (sipType_TYPE), sipTransferObj)) == NULL)
     {
       Py_DECREF(l);
       delete t;
@@ -265,7 +265,7 @@ template <TYPE>
       return 0;
 
     for (int i = 0; i < PyList_GET_SIZE(sipPy); ++i)
-      if (!sipCanConvertToInstance(PyList_GET_ITEM(sipPy, i), sipClass_TYPE, SIP_NOT_NONE))
+      if (!sipCanConvertToInstance(PyList_GET_ITEM(sipPy, i), (sipWrapperType *) sipTypeAsPyTypeObject (sipType_TYPE), SIP_NOT_NONE))
         return 0;
 
     return 1;
@@ -276,16 +276,16 @@ template <TYPE>
   for (int i = 0; i < PyList_GET_SIZE(sipPy); ++i)
   {
     int state;
-    TYPE* t = reinterpret_cast<TYPE *>(sipConvertToInstance(PyList_GET_ITEM(sipPy, i), sipClass_TYPE, sipTransferObj, SIP_NOT_NONE, &state, sipIsErr));
+    TYPE* t = reinterpret_cast<TYPE *>(sipConvertToInstance(PyList_GET_ITEM(sipPy, i), (sipWrapperType *) sipTypeAsPyTypeObject (sipType_TYPE), sipTransferObj, SIP_NOT_NONE, &state, sipIsErr));
 
     if (*sipIsErr)
     {
-      sipReleaseInstance(t, sipClass_TYPE, state);
+      sipReleaseInstance(t, (sipWrapperType *) sipTypeAsPyTypeObject (sipType_TYPE), state);
       delete qset;
       return 0;
     }
     qset->insert(*t);
-    sipReleaseInstance(t, sipClass_TYPE, state);
+    sipReleaseInstance(t, (sipWrapperType *) sipTypeAsPyTypeObject (sipType_TYPE), state);
   }
 
   *sipCppPtr = qset;
@@ -366,7 +366,7 @@ template<TYPE>
       Py_ssize_t j = 0;
       while (PyDict_Next(tobj, &j, &kobj2, &tobj2))
       {
-        if (!sipCanConvertToInstance(tobj2, sipClass_TYPE, SIP_NOT_NONE))
+        if (!sipCanConvertToInstance(tobj2, (sipWrapperType *) sipTypeAsPyTypeObject (sipType_TYPE), SIP_NOT_NONE))
           return 0;
       }
       
@@ -393,17 +393,17 @@ template<TYPE>
       int k2 = PyInt_AsLong(kobj2);
       int state;
       
-      TYPE* fa = reinterpret_cast<TYPE*>(sipConvertToInstance(tobj2, sipClass_TYPE, sipTransferObj,SIP_NOT_NONE,&state,sipIsErr));
+      TYPE* fa = reinterpret_cast<TYPE*>(sipConvertToInstance(tobj2, (sipWrapperType *) sipTypeAsPyTypeObject (sipType_TYPE), sipTransferObj,SIP_NOT_NONE,&state,sipIsErr));
       
       if (*sipIsErr)
       {
-        sipReleaseInstance(tobj2, sipClass_TYPE, state);
+        sipReleaseInstance(tobj2, (sipWrapperType *) sipTypeAsPyTypeObject (sipType_TYPE), state);
         delete qm;
         return 0;
       }
       
       qm2.insert(k2, *fa);
-      sipReleaseInstance(tobj2, sipClass_TYPE, state);
+      sipReleaseInstance(tobj2, (sipWrapperType *) sipTypeAsPyTypeObject (sipType_TYPE), state);
     }
     qm->insert(k, qm2);
   }
@@ -434,7 +434,7 @@ template<TYPE>
     {
         QString *t1 = new QString(i.key());
 
-        PyObject *t1obj = sipConvertFromNewInstance(t1, sipClass_QString, sipTransferObj);
+        PyObject *t1obj = sipConvertFromNewInstance(t1, (sipWrapperType *) sipTypeAsPyTypeObject (sipType_QString), sipTransferObj);
         PyObject *t2obj = PyInt_FromLong( (long) i.value() );
 
         if (t1obj == NULL || t2obj == NULL || PyDict_SetItem(d, t1obj, t2obj) < 0)
@@ -480,7 +480,7 @@ template<TYPE>
 
         while (PyDict_Next(sipPy, &i, &t1obj, &t2obj))
         {
-            if (!sipCanConvertToInstance(t1obj, sipClass_QString, SIP_NOT_NONE))
+            if (!sipCanConvertToInstance(t1obj, (sipWrapperType *) sipTypeAsPyTypeObject (sipType_QString), SIP_NOT_NONE))
                 return 0;
         } 
 
@@ -493,19 +493,19 @@ template<TYPE>
     {
         int state;
 
-        QString *t1 = reinterpret_cast<QString *>(sipConvertToInstance(t1obj, sipClass_QString, sipTransferObj, SIP_NOT_NONE, &state, sipIsErr));
+        QString *t1 = reinterpret_cast<QString *>(sipConvertToInstance(t1obj, (sipWrapperType *) sipTypeAsPyTypeObject (sipType_QString), sipTransferObj, SIP_NOT_NONE, &state, sipIsErr));
         QVariant::Type t2 = (QVariant::Type) PyInt_AsLong(t1obj);
 
         if (*sipIsErr)
         {
-            sipReleaseInstance(t1, sipClass_QString, state);
+            sipReleaseInstance(t1, (sipWrapperType *) sipTypeAsPyTypeObject (sipType_QString), state);
             delete qm;
             return 0;
         }
 
         qm->insert(*t1, t2);
 
-        sipReleaseInstance(t1, sipClass_QString, state);
+        sipReleaseInstance(t1, (sipWrapperType *) sipTypeAsPyTypeObject (sipType_QString), state);
     }
  
     *sipCppPtr = qm;
@@ -536,8 +536,8 @@ template<TYPE1, TYPE2>
         TYPE1 *t1 = new TYPE1(i.key());
         TYPE2 *t2 = i.value();
 
-        PyObject *t1obj = sipConvertFromNewInstance(t1, sipClass_TYPE1, sipTransferObj);
-        PyObject *t2obj = sipConvertFromInstance(t2, sipClass_TYPE2, sipTransferObj);
+        PyObject *t1obj = sipConvertFromNewInstance(t1, (sipWrapperType *) sipTypeAsPyTypeObject (sipType_TYPE1), sipTransferObj);
+        PyObject *t2obj = sipConvertFromInstance(t2, (sipWrapperType *) sipTypeAsPyTypeObject (sipType_TYPE2), sipTransferObj);
 
         if (t1obj == NULL || t2obj == NULL || PyDict_SetItem(d, t1obj, t2obj) < 0)
         {
@@ -581,10 +581,10 @@ template<TYPE1, TYPE2>
 
         while (PyDict_Next(sipPy, &i, &t1obj, &t2obj))
         {
-            if (!sipCanConvertToInstance(t1obj, sipClass_TYPE1, SIP_NOT_NONE))
+            if (!sipCanConvertToInstance(t1obj, (sipWrapperType *) sipTypeAsPyTypeObject (sipType_TYPE1), SIP_NOT_NONE))
                 return 0;
 
-            if (!sipCanConvertToInstance(t2obj, sipClass_TYPE2, SIP_NOT_NONE))
+            if (!sipCanConvertToInstance(t2obj, (sipWrapperType *) sipTypeAsPyTypeObject (sipType_TYPE2), SIP_NOT_NONE))
                 return 0;
         } 
 
@@ -597,22 +597,22 @@ template<TYPE1, TYPE2>
     {
         int state1, state2;
 
-        TYPE1 *t1 = reinterpret_cast<TYPE1 *>(sipConvertToInstance(t1obj, sipClass_TYPE1, sipTransferObj, SIP_NOT_NONE, &state1, sipIsErr));
-        TYPE2 *t2 = reinterpret_cast<TYPE2 *>(sipConvertToInstance(t2obj, sipClass_TYPE2, sipTransferObj, SIP_NOT_NONE, &state2, sipIsErr));
+        TYPE1 *t1 = reinterpret_cast<TYPE1 *>(sipConvertToInstance(t1obj, (sipWrapperType *) sipTypeAsPyTypeObject (sipType_TYPE1), sipTransferObj, SIP_NOT_NONE, &state1, sipIsErr));
+        TYPE2 *t2 = reinterpret_cast<TYPE2 *>(sipConvertToInstance(t2obj, (sipWrapperType *) sipTypeAsPyTypeObject (sipType_TYPE2), sipTransferObj, SIP_NOT_NONE, &state2, sipIsErr));
  
         if (*sipIsErr)
         {
-            sipReleaseInstance(t1, sipClass_TYPE1, state1);
-            sipReleaseInstance(t2, sipClass_TYPE2, state2);
+            sipReleaseInstance(t1, (sipWrapperType *) sipTypeAsPyTypeObject (sipType_TYPE1), state1);
+            sipReleaseInstance(t2, (sipWrapperType *) sipTypeAsPyTypeObject (sipType_TYPE2), state2);
 
             delete qm;
             return 0;
         }
 
         qm->insert(*t1, t2);
 
-        sipReleaseInstance(t1, sipClass_TYPE1, state1);
-        sipReleaseInstance(t2, sipClass_TYPE2, state2);
+        sipReleaseInstance(t1, (sipWrapperType *) sipTypeAsPyTypeObject (sipType_TYPE1), state1);
+        sipReleaseInstance(t2, (sipWrapperType *) sipTypeAsPyTypeObject (sipType_TYPE2), state2);
     }
  
     *sipCppPtr = qm;
@@ -644,7 +644,7 @@ template<double, TYPE2>
       const double t1 = i.key();
       TYPE2 * t2 = &i.value();
       PyObject *t1obj = PyFloat_FromDouble(t1);
-      PyObject *t2obj = sipConvertFromInstance(t2, sipClass_TYPE2, sipTransferObj);
+      PyObject *t2obj = sipConvertFromInstance(t2, (sipWrapperType *) sipTypeAsPyTypeObject (sipType_TYPE2), sipTransferObj);
       if (PyDict_GetItem(d, t1obj) == NULL) {
        PyObject *lst = PyList_New(0);
        PyDict_SetItem(d, t1obj, lst);
@@ -697,7 +697,7 @@ template<double, TYPE2>
         {
          for (int i = 0; i < PyList_GET_SIZE(t2obj); ++i) {
            if (!sipCanConvertToInstance(PyList_GET_ITEM(t2obj, i),
-                                        sipClass_TYPE2, SIP_NOT_NONE))
+                                        (sipWrapperType *) sipTypeAsPyTypeObject (sipType_TYPE2), SIP_NOT_NONE))
              return 0;
          }
         }
@@ -714,23 +714,23 @@ template<double, TYPE2>
          TYPE2 *t2 =
            reinterpret_cast<TYPE2 *>(sipConvertToInstance(PyList_GET_ITEM(t2obj,
                                                                           i),
-                                                          sipClass_TYPE2,
+                                                          (sipWrapperType *) sipTypeAsPyTypeObject (sipType_TYPE2),
                                                           sipTransferObj,
                                                           SIP_NOT_NONE,
                                                           &state2,
                                                           sipIsErr));
 
          if (*sipIsErr)
            {
-             sipReleaseInstance(t2, sipClass_TYPE2, state2);
+             sipReleaseInstance(t2, (sipWrapperType *) sipTypeAsPyTypeObject (sipType_TYPE2), state2);
 
              delete qm;
              return 0;
            }
 
          qm->insert(k, *t2);
 
-         sipReleaseInstance(t2, sipClass_TYPE2, state2);
+         sipReleaseInstance(t2, (sipWrapperType *) sipTypeAsPyTypeObject (sipType_TYPE2), state2);
        }
     }
 
@@ -759,7 +759,7 @@ template<double, TYPE2>
         QgsOverlayObject* oobj = new QgsOverlayObject(*it.value());
 
         PyObject* keyobj = PyInt_FromLong(it.key());
-        PyObject* pyOobj = sipConvertFromInstance(oobj, sipClass_QgsOverlayObject, sipTransferObj);
+        PyObject* pyOobj = sipConvertFromInstance(oobj, (sipWrapperType *) sipTypeAsPyTypeObject (sipType_QgsOverlayObject), sipTransferObj);
         PyDict_SetItem(d, keyobj, pyOobj);
 
         if(pyOobj == NULL || keyobj == NULL || PyDict_SetItem(d, keyobj, pyOobj) < 0)
@@ -797,18 +797,18 @@ template<double, TYPE2>
     {
         int state;
         int t1 = (int)(PyFloat_AsDouble(t1obj));
-        QgsOverlayObject* t2 = reinterpret_cast<QgsOverlayObject*>(sipConvertToInstance(t2obj, sipClass_QgsOverlayObject, sipTransferObj, SIP_NOT_NONE, &state, sipIsErr));
+        QgsOverlayObject* t2 = reinterpret_cast<QgsOverlayObject*>(sipConvertToInstance(t2obj, (sipWrapperType *) sipTypeAsPyTypeObject (sipType_QgsOverlayObject), sipTransferObj, SIP_NOT_NONE, &state, sipIsErr));
 
         if (*sipIsErr)
         {
-            sipReleaseInstance(t2, sipClass_QgsOverlayObject, state);
+            sipReleaseInstance(t2, (sipWrapperType *) sipTypeAsPyTypeObject (sipType_QgsOverlayObject), state);
             delete qm;
             return 0;
         }
 
         qm->insert(t1, t2);
 
-        sipReleaseInstance(t2, sipClass_QgsOverlayObject, state);
+        sipReleaseInstance(t2, (sipWrapperType *) sipTypeAsPyTypeObject (sipType_QgsOverlayObject), state);
     }
 
     *sipCppPtr = qm;

Original file line number	Diff line number	Diff line change
`@@ -79,17 +79,17 @@ template <TYPE>`
`79`	`79`	`for (int i = 0; i < PyList_GET_SIZE(sipPy); ++i)`
`80`	`80`	`{`
`81`	`81`	`int state;`
`82`		`- //TYPE t = reinterpret_cast<TYPE >(sipConvertToInstance(PyList_GET_ITEM(sipPy, i), sipClass_TYPE, sipTransferObj, SIP_NOT_NONE, &state, sipIsErr));`
	`82`	`+ //TYPE t = reinterpret_cast<TYPE >(sipConvertToInstance(PyList_GET_ITEM(sipPy, i), (sipWrapperType *) sipTypeAsPyTypeObject (sipType_TYPE), sipTransferObj, SIP_NOT_NONE, &state, sipIsErr));`
`83`	`83`	`QVector<TYPE> * t = reinterpret_cast< QVector<TYPE> * >(sipConvertToMappedType(PyList_GET_ITEM(sipPy, i), qvector_qgspoint, sipTransferObj, SIP_NOT_NONE, &state, sipIsErr));`
`84`	`84`
`85`	`85`	`if (*sipIsErr)`
`86`	`86`	`{`
`87`		`- sipReleaseInstance(t, sipClass_TYPE, state);`
	`87`	`+ sipReleaseInstance(t, (sipWrapperType *) sipTypeAsPyTypeObject (sipType_TYPE), state);`
`88`	`88`	`delete ql;`
`89`	`89`	`return 0;`
`90`	`90`	`}`
`91`	`91`	`ql->append(*t);`
`92`		`- sipReleaseInstance(t, sipClass_TYPE, state);`
	`92`	`+ sipReleaseInstance(t, (sipWrapperType *) sipTypeAsPyTypeObject (sipType_TYPE), state);`
`93`	`93`	`}`
`94`	`94`
`95`	`95`	`*sipCppPtr = ql;`
`@@ -155,17 +155,17 @@ template <TYPE>`
`155`	`155`	`for (int i = 0; i < PyList_GET_SIZE(sipPy); ++i)`
`156`	`156`	`{`
`157`	`157`	`int state;`
`158`		`- //TYPE t = reinterpret_cast<TYPE >(sipConvertToInstance(PyList_GET_ITEM(sipPy, i), sipClass_TYPE, sipTransferObj, SIP_NOT_NONE, &state, sipIsErr));`
	`158`	`+ //TYPE t = reinterpret_cast<TYPE >(sipConvertToInstance(PyList_GET_ITEM(sipPy, i), (sipWrapperType *) sipTypeAsPyTypeObject (sipType_TYPE), sipTransferObj, SIP_NOT_NONE, &state, sipIsErr));`
`159`	`159`	`QVector<QVector<TYPE> > * t = reinterpret_cast< QVector< QVector<TYPE> > * >(sipConvertToMappedType(PyList_GET_ITEM(sipPy, i), qvector_qgspoint, sipTransferObj, SIP_NOT_NONE, &state, sipIsErr));`
`160`	`160`
`161`	`161`	`if (*sipIsErr)`
`162`	`162`	`{`
`163`		`- sipReleaseInstance(t, sipClass_TYPE, state);`
	`163`	`+ sipReleaseInstance(t, (sipWrapperType *) sipTypeAsPyTypeObject (sipType_TYPE), state);`
`164`	`164`	`delete ql;`
`165`	`165`	`return 0;`
`166`	`166`	`}`
`167`	`167`	`ql->append(*t);`
`168`		`- sipReleaseInstance(t, sipClass_TYPE, state);`
	`168`	`+ sipReleaseInstance(t, (sipWrapperType *) sipTypeAsPyTypeObject (sipType_TYPE), state);`
`169`	`169`	`}`
`170`	`170`
`171`	`171`	`*sipCppPtr = ql;`
`@@ -245,7 +245,7 @@ template <TYPE>`
`245`	`245`	`TYPE t = new TYPE(it);`
`246`	`246`	`PyObject *tobj;`
`247`	`247`
`248`		`- if ((tobj = sipConvertFromNewInstance(t, sipClass_TYPE, sipTransferObj)) == NULL)`
	`248`	`+ if ((tobj = sipConvertFromNewInstance(t, (sipWrapperType *) sipTypeAsPyTypeObject (sipType_TYPE), sipTransferObj)) == NULL)`
`249`	`249`	`{`
`250`	`250`	`Py_DECREF(l);`
`251`	`251`	`delete t;`
`@@ -265,7 +265,7 @@ template <TYPE>`
`265`	`265`	`return 0;`
`266`	`266`
`267`	`267`	`for (int i = 0; i < PyList_GET_SIZE(sipPy); ++i)`
`268`		`- if (!sipCanConvertToInstance(PyList_GET_ITEM(sipPy, i), sipClass_TYPE, SIP_NOT_NONE))`
	`268`	`+ if (!sipCanConvertToInstance(PyList_GET_ITEM(sipPy, i), (sipWrapperType *) sipTypeAsPyTypeObject (sipType_TYPE), SIP_NOT_NONE))`
`269`	`269`	`return 0;`
`270`	`270`
`271`	`271`	`return 1;`
`@@ -276,16 +276,16 @@ template <TYPE>`
`276`	`276`	`for (int i = 0; i < PyList_GET_SIZE(sipPy); ++i)`
`277`	`277`	`{`
`278`	`278`	`int state;`
`279`		`- TYPE* t = reinterpret_cast<TYPE *>(sipConvertToInstance(PyList_GET_ITEM(sipPy, i), sipClass_TYPE, sipTransferObj, SIP_NOT_NONE, &state, sipIsErr));`
	`279`	`+ TYPE* t = reinterpret_cast<TYPE >(sipConvertToInstance(PyList_GET_ITEM(sipPy, i), (sipWrapperType ) sipTypeAsPyTypeObject (sipType_TYPE), sipTransferObj, SIP_NOT_NONE, &state, sipIsErr));`
`280`	`280`
`281`	`281`	`if (*sipIsErr)`
`282`	`282`	`{`
`283`		`- sipReleaseInstance(t, sipClass_TYPE, state);`
	`283`	`+ sipReleaseInstance(t, (sipWrapperType *) sipTypeAsPyTypeObject (sipType_TYPE), state);`
`284`	`284`	`delete qset;`
`285`	`285`	`return 0;`
`286`	`286`	`}`
`287`	`287`	`qset->insert(*t);`
`288`		`- sipReleaseInstance(t, sipClass_TYPE, state);`
	`288`	`+ sipReleaseInstance(t, (sipWrapperType *) sipTypeAsPyTypeObject (sipType_TYPE), state);`
`289`	`289`	`}`
`290`	`290`
`291`	`291`	`*sipCppPtr = qset;`
`@@ -366,7 +366,7 @@ template<TYPE>`
`366`	`366`	`Py_ssize_t j = 0;`
`367`	`367`	`while (PyDict_Next(tobj, &j, &kobj2, &tobj2))`
`368`	`368`	`{`
`369`		`- if (!sipCanConvertToInstance(tobj2, sipClass_TYPE, SIP_NOT_NONE))`
	`369`	`+ if (!sipCanConvertToInstance(tobj2, (sipWrapperType *) sipTypeAsPyTypeObject (sipType_TYPE), SIP_NOT_NONE))`
`370`	`370`	`return 0;`
`371`	`371`	`}`
`372`	`372`
`@@ -393,17 +393,17 @@ template<TYPE>`
`393`	`393`	`int k2 = PyInt_AsLong(kobj2);`
`394`	`394`	`int state;`
`395`	`395`
`396`		`- TYPE* fa = reinterpret_cast<TYPE*>(sipConvertToInstance(tobj2, sipClass_TYPE, sipTransferObj,SIP_NOT_NONE,&state,sipIsErr));`
	`396`	`+ TYPE* fa = reinterpret_cast<TYPE>(sipConvertToInstance(tobj2, (sipWrapperType ) sipTypeAsPyTypeObject (sipType_TYPE), sipTransferObj,SIP_NOT_NONE,&state,sipIsErr));`
`397`	`397`
`398`	`398`	`if (*sipIsErr)`
`399`	`399`	`{`
`400`		`- sipReleaseInstance(tobj2, sipClass_TYPE, state);`
	`400`	`+ sipReleaseInstance(tobj2, (sipWrapperType *) sipTypeAsPyTypeObject (sipType_TYPE), state);`
`401`	`401`	`delete qm;`
`402`	`402`	`return 0;`
`403`	`403`	`}`
`404`	`404`
`405`	`405`	`qm2.insert(k2, *fa);`
`406`		`- sipReleaseInstance(tobj2, sipClass_TYPE, state);`
	`406`	`+ sipReleaseInstance(tobj2, (sipWrapperType *) sipTypeAsPyTypeObject (sipType_TYPE), state);`
`407`	`407`	`}`
`408`	`408`	`qm->insert(k, qm2);`
`409`	`409`	`}`
`@@ -434,7 +434,7 @@ template<TYPE>`
`434`	`434`	`{`
`435`	`435`	`QString *t1 = new QString(i.key());`
`436`	`436`
`437`		`- PyObject *t1obj = sipConvertFromNewInstance(t1, sipClass_QString, sipTransferObj);`
	`437`	`+ PyObject t1obj = sipConvertFromNewInstance(t1, (sipWrapperType ) sipTypeAsPyTypeObject (sipType_QString), sipTransferObj);`
`438`	`438`	`PyObject *t2obj = PyInt_FromLong( (long) i.value() );`
`439`	`439`
`440`	`440`	`if (t1obj == NULL \|\| t2obj == NULL \|\| PyDict_SetItem(d, t1obj, t2obj) < 0)`
`@@ -480,7 +480,7 @@ template<TYPE>`
`480`	`480`
`481`	`481`	`while (PyDict_Next(sipPy, &i, &t1obj, &t2obj))`
`482`	`482`	`{`
`483`		`- if (!sipCanConvertToInstance(t1obj, sipClass_QString, SIP_NOT_NONE))`
	`483`	`+ if (!sipCanConvertToInstance(t1obj, (sipWrapperType *) sipTypeAsPyTypeObject (sipType_QString), SIP_NOT_NONE))`
`484`	`484`	`return 0;`
`485`	`485`	`}`
`486`	`486`
`@@ -493,19 +493,19 @@ template<TYPE>`
`493`	`493`	`{`
`494`	`494`	`int state;`
`495`	`495`
`496`		`- QString t1 = reinterpret_cast<QString >(sipConvertToInstance(t1obj, sipClass_QString, sipTransferObj, SIP_NOT_NONE, &state, sipIsErr));`
	`496`	`+ QString t1 = reinterpret_cast<QString >(sipConvertToInstance(t1obj, (sipWrapperType *) sipTypeAsPyTypeObject (sipType_QString), sipTransferObj, SIP_NOT_NONE, &state, sipIsErr));`
`497`	`497`	`QVariant::Type t2 = (QVariant::Type) PyInt_AsLong(t1obj);`
`498`	`498`
`499`	`499`	`if (*sipIsErr)`
`500`	`500`	`{`
`501`		`- sipReleaseInstance(t1, sipClass_QString, state);`
	`501`	`+ sipReleaseInstance(t1, (sipWrapperType *) sipTypeAsPyTypeObject (sipType_QString), state);`
`502`	`502`	`delete qm;`
`503`	`503`	`return 0;`
`504`	`504`	`}`
`505`	`505`
`506`	`506`	`qm->insert(*t1, t2);`
`507`	`507`
`508`		`- sipReleaseInstance(t1, sipClass_QString, state);`
	`508`	`+ sipReleaseInstance(t1, (sipWrapperType *) sipTypeAsPyTypeObject (sipType_QString), state);`
`509`	`509`	`}`
`510`	`510`
`511`	`511`	`*sipCppPtr = qm;`
`@@ -536,8 +536,8 @@ template<TYPE1, TYPE2>`
`536`	`536`	`TYPE1 *t1 = new TYPE1(i.key());`
`537`	`537`	`TYPE2 *t2 = i.value();`
`538`	`538`
`539`		`- PyObject *t1obj = sipConvertFromNewInstance(t1, sipClass_TYPE1, sipTransferObj);`
`540`		`- PyObject *t2obj = sipConvertFromInstance(t2, sipClass_TYPE2, sipTransferObj);`
	`539`	`+ PyObject t1obj = sipConvertFromNewInstance(t1, (sipWrapperType ) sipTypeAsPyTypeObject (sipType_TYPE1), sipTransferObj);`
	`540`	`+ PyObject t2obj = sipConvertFromInstance(t2, (sipWrapperType ) sipTypeAsPyTypeObject (sipType_TYPE2), sipTransferObj);`
`541`	`541`
`542`	`542`	`if (t1obj == NULL \|\| t2obj == NULL \|\| PyDict_SetItem(d, t1obj, t2obj) < 0)`
`543`	`543`	`{`
`@@ -581,10 +581,10 @@ template<TYPE1, TYPE2>`
`581`	`581`
`582`	`582`	`while (PyDict_Next(sipPy, &i, &t1obj, &t2obj))`
`583`	`583`	`{`
`584`		`- if (!sipCanConvertToInstance(t1obj, sipClass_TYPE1, SIP_NOT_NONE))`
	`584`	`+ if (!sipCanConvertToInstance(t1obj, (sipWrapperType *) sipTypeAsPyTypeObject (sipType_TYPE1), SIP_NOT_NONE))`
`585`	`585`	`return 0;`
`586`	`586`
`587`		`- if (!sipCanConvertToInstance(t2obj, sipClass_TYPE2, SIP_NOT_NONE))`
	`587`	`+ if (!sipCanConvertToInstance(t2obj, (sipWrapperType *) sipTypeAsPyTypeObject (sipType_TYPE2), SIP_NOT_NONE))`
`588`	`588`	`return 0;`
`589`	`589`	`}`
`590`	`590`
`@@ -597,22 +597,22 @@ template<TYPE1, TYPE2>`
`597`	`597`	`{`
`598`	`598`	`int state1, state2;`
`599`	`599`
`600`		`- TYPE1 t1 = reinterpret_cast<TYPE1 >(sipConvertToInstance(t1obj, sipClass_TYPE1, sipTransferObj, SIP_NOT_NONE, &state1, sipIsErr));`
`601`		`- TYPE2 t2 = reinterpret_cast<TYPE2 >(sipConvertToInstance(t2obj, sipClass_TYPE2, sipTransferObj, SIP_NOT_NONE, &state2, sipIsErr));`
	`600`	`+ TYPE1 t1 = reinterpret_cast<TYPE1 >(sipConvertToInstance(t1obj, (sipWrapperType *) sipTypeAsPyTypeObject (sipType_TYPE1), sipTransferObj, SIP_NOT_NONE, &state1, sipIsErr));`
	`601`	`+ TYPE2 t2 = reinterpret_cast<TYPE2 >(sipConvertToInstance(t2obj, (sipWrapperType *) sipTypeAsPyTypeObject (sipType_TYPE2), sipTransferObj, SIP_NOT_NONE, &state2, sipIsErr));`
`602`	`602`
`603`	`603`	`if (*sipIsErr)`
`604`	`604`	`{`
`605`		`- sipReleaseInstance(t1, sipClass_TYPE1, state1);`
`606`		`- sipReleaseInstance(t2, sipClass_TYPE2, state2);`
	`605`	`+ sipReleaseInstance(t1, (sipWrapperType *) sipTypeAsPyTypeObject (sipType_TYPE1), state1);`
	`606`	`+ sipReleaseInstance(t2, (sipWrapperType *) sipTypeAsPyTypeObject (sipType_TYPE2), state2);`
`607`	`607`
`608`	`608`	`delete qm;`
`609`	`609`	`return 0;`
`610`	`610`	`}`
`611`	`611`
`612`	`612`	`qm->insert(*t1, t2);`
`613`	`613`
`614`		`- sipReleaseInstance(t1, sipClass_TYPE1, state1);`
`615`		`- sipReleaseInstance(t2, sipClass_TYPE2, state2);`
	`614`	`+ sipReleaseInstance(t1, (sipWrapperType *) sipTypeAsPyTypeObject (sipType_TYPE1), state1);`
	`615`	`+ sipReleaseInstance(t2, (sipWrapperType *) sipTypeAsPyTypeObject (sipType_TYPE2), state2);`
`616`	`616`	`}`
`617`	`617`
`618`	`618`	`*sipCppPtr = qm;`
`@@ -644,7 +644,7 @@ template<double, TYPE2>`
`644`	`644`	`const double t1 = i.key();`
`645`	`645`	`TYPE2 * t2 = &i.value();`
`646`	`646`	`PyObject *t1obj = PyFloat_FromDouble(t1);`
`647`		`- PyObject *t2obj = sipConvertFromInstance(t2, sipClass_TYPE2, sipTransferObj);`
	`647`	`+ PyObject t2obj = sipConvertFromInstance(t2, (sipWrapperType ) sipTypeAsPyTypeObject (sipType_TYPE2), sipTransferObj);`
`648`	`648`	`if (PyDict_GetItem(d, t1obj) == NULL) {`
`649`	`649`	`PyObject *lst = PyList_New(0);`
`650`	`650`	`PyDict_SetItem(d, t1obj, lst);`
`@@ -697,7 +697,7 @@ template<double, TYPE2>`
`697`	`697`	`{`
`698`	`698`	`for (int i = 0; i < PyList_GET_SIZE(t2obj); ++i) {`
`699`	`699`	`if (!sipCanConvertToInstance(PyList_GET_ITEM(t2obj, i),`
`700`		`- sipClass_TYPE2, SIP_NOT_NONE))`
	`700`	`+ (sipWrapperType *) sipTypeAsPyTypeObject (sipType_TYPE2), SIP_NOT_NONE))`
`701`	`701`	`return 0;`
`702`	`702`	`}`
`703`	`703`	`}`
`@@ -714,23 +714,23 @@ template<double, TYPE2>`
`714`	`714`	`TYPE2 *t2 =`
`715`	`715`	`reinterpret_cast<TYPE2 *>(sipConvertToInstance(PyList_GET_ITEM(t2obj,`
`716`	`716`	`i),`
`717`		`- sipClass_TYPE2,`
	`717`	`+ (sipWrapperType *) sipTypeAsPyTypeObject (sipType_TYPE2),`
`718`	`718`	`sipTransferObj,`
`719`	`719`	`SIP_NOT_NONE,`
`720`	`720`	`&state2,`
`721`	`721`	`sipIsErr));`
`722`	`722`
`723`	`723`	`if (*sipIsErr)`
`724`	`724`	`{`
`725`		`- sipReleaseInstance(t2, sipClass_TYPE2, state2);`
	`725`	`+ sipReleaseInstance(t2, (sipWrapperType *) sipTypeAsPyTypeObject (sipType_TYPE2), state2);`
`726`	`726`
`727`	`727`	`delete qm;`
`728`	`728`	`return 0;`
`729`	`729`	`}`
`730`	`730`
`731`	`731`	`qm->insert(k, *t2);`
`732`	`732`
`733`		`- sipReleaseInstance(t2, sipClass_TYPE2, state2);`
	`733`	`+ sipReleaseInstance(t2, (sipWrapperType *) sipTypeAsPyTypeObject (sipType_TYPE2), state2);`
`734`	`734`	`}`
`735`	`735`	`}`
`736`	`736`
`@@ -759,7 +759,7 @@ template<double, TYPE2>`
`759`	`759`	`QgsOverlayObject* oobj = new QgsOverlayObject(*it.value());`
`760`	`760`
`761`	`761`	`PyObject* keyobj = PyInt_FromLong(it.key());`
`762`		`- PyObject* pyOobj = sipConvertFromInstance(oobj, sipClass_QgsOverlayObject, sipTransferObj);`
	`762`	`+ PyObject* pyOobj = sipConvertFromInstance(oobj, (sipWrapperType *) sipTypeAsPyTypeObject (sipType_QgsOverlayObject), sipTransferObj);`
`763`	`763`	`PyDict_SetItem(d, keyobj, pyOobj);`
`764`	`764`
`765`	`765`	`if(pyOobj == NULL \|\| keyobj == NULL \|\| PyDict_SetItem(d, keyobj, pyOobj) < 0)`
`@@ -797,18 +797,18 @@ template<double, TYPE2>`
`797`	`797`	`{`
`798`	`798`	`int state;`
`799`	`799`	`int t1 = (int)(PyFloat_AsDouble(t1obj));`
`800`		`- QgsOverlayObject* t2 = reinterpret_cast<QgsOverlayObject*>(sipConvertToInstance(t2obj, sipClass_QgsOverlayObject, sipTransferObj, SIP_NOT_NONE, &state, sipIsErr));`
	`800`	`+ QgsOverlayObject* t2 = reinterpret_cast<QgsOverlayObject>(sipConvertToInstance(t2obj, (sipWrapperType ) sipTypeAsPyTypeObject (sipType_QgsOverlayObject), sipTransferObj, SIP_NOT_NONE, &state, sipIsErr));`
`801`	`801`
`802`	`802`	`if (*sipIsErr)`
`803`	`803`	`{`
`804`		`- sipReleaseInstance(t2, sipClass_QgsOverlayObject, state);`
	`804`	`+ sipReleaseInstance(t2, (sipWrapperType *) sipTypeAsPyTypeObject (sipType_QgsOverlayObject), state);`
`805`	`805`	`delete qm;`
`806`	`806`	`return 0;`
`807`	`807`	`}`
`808`	`808`
`809`	`809`	`qm->insert(t1, t2);`
`810`	`810`
`811`		`- sipReleaseInstance(t2, sipClass_QgsOverlayObject, state);`
	`811`	`+ sipReleaseInstance(t2, (sipWrapperType *) sipTypeAsPyTypeObject (sipType_QgsOverlayObject), state);`
`812`	`812`	`}`
`813`	`813`
`814`	`814`	`*sipCppPtr = qm;`