added conversion rules for QVector and QMap containers

PySide/QtCore/qlist_conversions.h

@@ -1,20 +1,20 @@
-template <typename StdList>
+template <typename qlist>
 struct Converter_qlist
 {
-    static PyObject* toPython(StdList holder)
+    static PyObject* toPython(qlist holder)
     {
         PyObject* result = PyList_New(holder.size());
         for (int i = 0; i < holder.size(); i++) {
-            PyList_SET_ITEM(result, i, Converter<typename StdList::value_type>::toPython(holder.at(i)));
+            PyList_SET_ITEM(result, i, Converter<typename qlist::value_type>::toPython(holder.at(i)));
         }
         return result;
     }
-    static StdList toCpp(PyObject* pyobj)
+    static qlist toCpp(PyObject* pyobj)
     {
-        StdList result;
+        qlist result;
         for (int i = 0; i < PySequence_Size(pyobj); i++) {
             PyObject* pyItem = PySequence_GetItem(pyobj, i);
-            result.append(Converter<typename StdList::value_type>::toCpp(pyItem));
+            result.append(Converter<typename qlist::value_type>::toCpp(pyItem));
         }
         return result;
     }

PySide/QtCore/qmap_conversions.h

@@ -0,0 +1,40 @@
+template <typename qmap>
+struct Converter_qmap
+{
+    static PyObject* toPython(qmap map)
+    {
+        PyObject* result = PyDict_New();
+
+        QMapIterator<typename qmap::key_type, typename qmap::mapped_type> it(map);
+        while (it.hasNext()) {
+            it.next();
+            PyDict_SetItem(result,
+                           Converter<typename qmap::key_type>::toPython(it.key()),
+                           Converter<typename qmap::mapped_type>::toPython(it.value()));
+        }
+
+        return result;
+    }
+    static qmap toCpp(PyObject* pyobj)
+    {
+        qmap result;
+
+        PyObject* key;
+        PyObject* value;
+        Py_ssize_t pos = 0;
+
+        Py_INCREF(pyobj);
+
+        while (PyDict_Next(pyobj, &pos, &key, &value)) {
+            result.insert(Converter<typename qmap::key_type>::toCpp(key),
+                          Converter<typename qmap::mapped_type>::toCpp(value));
+        }
+
+        Py_DECREF(pyobj);
+
+        return result;
+    }
+};
+
+template<typename KT, typename VT>
+struct Converter<QMap<KT, VT> > : Converter_qmap<QMap<KT, VT> > {};

PySide/QtCore/qpair_conversions.h

@@ -1,22 +1,22 @@
-template <typename StdPair>
+template <typename qpair>
 struct Converter_qpair
 {
-    static PyObject* toPython(StdPair holder)
+    static PyObject* toPython(qpair holder)
     {
-        typename StdPair::first_type first(holder.first);
+        typename qpair::first_type first(holder.first);
-        typename StdPair::second_type second(holder.second);
+        typename qpair::second_type second(holder.second);
         PyObject* tuple = PyTuple_New(2);
-        PyTuple_SET_ITEM(tuple, 0, Converter<typename StdPair::first_type>::toPython(first));
+        PyTuple_SET_ITEM(tuple, 0, Converter<typename qpair::first_type>::toPython(first));
-        PyTuple_SET_ITEM(tuple, 1, Converter<typename StdPair::second_type>::toPython(second));
+        PyTuple_SET_ITEM(tuple, 1, Converter<typename qpair::second_type>::toPython(second));
         return tuple;
     }
-    static StdPair toCpp(PyObject* pyobj)
+    static qpair toCpp(PyObject* pyobj)
     {
-        StdPair result;
+        qpair result;
         PyObject* pyFirst = PySequence_GetItem(pyobj, 0);
         PyObject* pySecond = PySequence_GetItem(pyobj, 1);
-        result.first = Converter<typename StdPair::first_type>::toCpp(pyFirst);
+        result.first = Converter<typename qpair::first_type>::toCpp(pyFirst);
-        result.second = Converter<typename StdPair::second_type>::toCpp(pySecond);
+        result.second = Converter<typename qpair::second_type>::toCpp(pySecond);
         return result;
     }
 };

PySide/QtCore/qvector_conversions.h

@@ -0,0 +1,24 @@
+template <typename qvector>
+struct Converter_qvector
+{
+    static PyObject* toPython(qvector vector)
+    {
+        PyObject* result = PyList_New(vector.size());
+        for (int i = 0; i < vector.size(); i++) {
+            PyList_SET_ITEM(result, i, Converter<typename qvector::value_type>::toPython(vector.at(i)));
+        }
+        return result;
+    }
+    static qvector toCpp(PyObject* pyobj)
+    {
+        qvector result;
+        for (int i = 0; i < PySequence_Size(pyobj); i++) {
+            PyObject* pyItem = PySequence_GetItem(pyobj, i);
+            result.append(Converter<typename qvector::value_type>::toCpp(pyItem));
+        }
+        return result;
+    }
+};
+
+template<typename T>
+struct Converter<QVector<T> > : Converter_qvector<QVector<T> > {};

PySide/QtCore/typesystem_core.xml

@@ -326,7 +326,10 @@
   <rejection class="QList" function-name="toSet"/>
   <rejection class="QList" function-name="toStdList" />
 
-  <container-type name="QVector" type="vector"/>
+  <container-type name="QVector" type="vector">
+    <conversion-rule file="qvector_conversions.h"/>
+    <include file-name="QVector" location="global"/>
+  </container-type>
   <rejection class="QVector" function-name="back"/>
   <rejection class="QVector" function-name="begin"/>
   <rejection class="QVector" function-name="constBegin"/>
@@ -353,7 +356,10 @@
 
   <container-type name="QHash" type="hash"/>
   <container-type name="QLinkedList" type="linked-list"/>
-  <container-type name="QMap" type="map"/>
+  <container-type name="QMap" type="map">
+    <conversion-rule file="qmap_conversions.h"/>
+    <include file-name="QMap" location="global"/>
+  </container-type>
   <container-type name="QMultiMap" type="multi-map"/>
   <container-type name="QPair" type="pair">
     <conversion-rule file="qpair_conversions.h"/>