swig：如何使 QList<T> 可迭代，例如 std::vector

Question

我正在使用 SWIG 为我的 qt 应用程序生成 Python 绑定。我有几个地方使用 QLists and I would like to integrate those QLists like std::vector from the SWIG Library (see http://www.swig.org/Doc1.3/Library.html#Library_nn15).
这意味着：

QList 对象应该可以从 python 迭代（=它们必须是一个可迭代的 python 对象）
应该可以将 python 列表传递给接受 qlist
...以及 std::vector

为此，我使用了以下代码： https://github.com/osmandapp/OsmAnd-core/blob/master/swig/java/QList.i
稍后在我使用 QLists 的类中，我添加了如下代码：

%import "qlist.i"
%template(listfilter) QList<Interface_Filter*>;

class A {
    public:
    //.....
    QList<Interface_Filter*> get_filters();
};

目前为止这有效，但它没有给我与 std::vector 的那种集成。我无法找出 std_vector.i、std_container.i、...的哪些部分使对象可迭代。
我需要如何扩展 QList 接口文件以使我的 QList 可迭代？

Answer 1

如 docs 中所述，您需要以下内容：

QList 应该在 python __iter__() 中有一个方法，return 是一个迭代器对象（tp_iter 如果您在 C 中实现它）。
迭代器对象应该实现 __iter__() 和 return 本身
迭代器对象应实现 next()，即 return 下一项或在完成后引发 StopIteration。

在 python 中可能最容易实现，但您也可以在 C 中实现它。

另一种选择是使用 python 生成器来避免实现迭代器类型。为此，您 QList 需要实现 __iter__() 但不是 return 迭代器，您只需 yield 值。

提到的方法只需要对 python 可见。您不必在 C/Java.

中提供它们

另见 SWIG interfacing C library to Python (Creating 'iterable' Python data type from C 'sequence' struct)

Answer 2

You provided an answer to the question "How to make a python Object iterable", but I asked for "How do I need to extend the QList interface file to make my QList's iterable?" which is more a SWIG, than a python related question.

我测试了 http://www.swig.org/Doc1.3/Library.html#Library_nn15 with Java, C# and Python. Only Python and C# provide iterators. The generated interface of Java doesn't implement Iterable 中的示例或类似的东西。据我所知，你的问题与目标语言有关。

也许延长 MutableSequence 是您的一个选择。您必须实现的唯一方法是 __getitem__、__setitem__、__delitem__、__len__ 和 insert，方法是将它们委托给 QList 的相应方法。之后你生成的 class 是可迭代的。

Answer 3

您要的是一个 qlist.i swig 文件，它在 python 中为 QList 实现了与 std_vector.i 在 [=15] 中相同的集成级别=] -- 是一项不平凡的任务。

我提供了一个非常基本的扩展 qlist.i 文件（和 qlisttest.i 向您展示如何使用它）并将尝试解释需要哪些步骤。

qlist.i:

%{
#include <QList>
%}

%pythoncode %{
class QListIterator:
    def __init__(self, qlist):
        self.index = 0
        self.qlist = qlist
    def __iter__(self):
        return self
    def next(self):
        if self.index >= self.qlist.size():
            raise StopIteration;
        ret = self.qlist.get(self.index)
        self.index += 1
        return ret
    __next__ = next
%}

template<class T> class QList {
public:
class iterator;
typedef size_t size_type;
typedef T value_type;
typedef const value_type& const_reference;
QList();
size_type size() const;
void reserve(size_type n);
%rename(isEmpty) empty;
bool empty() const;
void clear();
%rename(add) push_back;
void push_back(const value_type& x);
%extend {
    const_reference get(int i) throw (std::out_of_range) {
    int size = int(self->size());
    if (i>=0 && i<size)
        return (*self)[i];
    else
        throw std::out_of_range("QList index out of range");
    }
    void set(int i, const value_type& val) throw (std::out_of_range) {
    int size = int(self->size());
    if (i>=0 && i<size)
        (*self)[i] = val;
    else
        throw std::out_of_range("QList index out of range");
    }
    int __len__() {
    return self->size();
    }
    const_reference __getitem__(int i) throw (std::out_of_range) {
    int size = int(self->size());
    if (i>=0 && i<size)
        return (*self)[i];
    else
        throw std::out_of_range("QList index out of range");
    }
    %pythoncode %{
    def __iter__(self):
        return QListIterator(self)
    %}
}
};

%define %qlist_conversions(Type...)
%typemap(in) const QList< Type > & (bool free_qlist)
{
free_qlist = false;
if ((SWIG_ConvertPtr($input, (void **) &, _descriptor, 0)) == -1) {
    if (!PyList_Check($input)) {
    PyErr_Format(PyExc_TypeError, "QList or python list required.");
    SWIG_fail;
    }
    Py_ssize_t len = PyList_Size($input);
    QList< Type > * qlist = new QList< Type >();
    free_qlist = true;
    qlist->reserve(len);
    for (Py_ssize_t index = 0; index < len; ++index) {
    PyObject *item = PyList_GetItem($input,index);
    Type* c_item;
    if ((SWIG_ConvertPtr(item, (void **) &c_item, $descriptor(Type *),0)) == -1) {
        delete qlist;
        free_qlist = false;
        PyErr_Format(PyExc_TypeError, "List element of wrong type encountered.");
        SWIG_fail;
    }
    qlist->append(*c_item);
    }
     = qlist;
}
}
%typemap(freearg) const QList< Type > &
{ if (free_qlist$argnum and ) delete ; }    
%enddef

qlisttest.i:

%module qlist;
%include "qlist.i"

%inline %{
class Foo {
public:
    int foo;
};
%}

%template(QList_Foo) QList<Foo>;
%qlist_conversions(Foo);

%inline %{  
int sumList(const QList<Foo> & list) {
    int sum = 0;
    for (int i = 0; i < list.size(); ++i) {
        sum += list[i].foo;
    }
    return sum;
}
%}

包装 QList 使其及其方法可从 python
访问这是通过使（部分）class 定义可用于 swig 来实现的。这就是您当前的 qlist.i 所做的。
注意：您可能需要为将 const_reference 定义为 const T* 的情况 QList<T*> 添加 "template specialization"，因为您使用的是 QList 的指针。否则，QList<T*>::const_reference 将是 const T*&，这显然会使 swig 感到困惑。（参见 swig/Lib/std/std_vector.i）
python列表和QList
之间的自动转换这通常是通过使用 swig typemaps 来实现的。例如，如果您希望函数 f(const QList<int>& list) 能够接受 python 列表，您需要指定一个输入类型映射来执行从 python 列表到 QList<int>:
```
%typemap(in) const QList<int> &
{
    PyObject * py_list = $input;
    [check if py_list is really a python list of integers]
    QList<int>* qlist = new QList<int>();
    [copy the data from the py_list to the qlist]
     = qlist;
}
%typemap(freearg) const QList<int> &
{ if () delete ; }
```
这里的情况在几个方面比较困难：
- 您希望能够传递一个 python 列表或一个包装的 QList：为此，您需要处理这两种情况类型图。
- 您想将包装类型 T 的 python 列表转换为 QList<T>:
  这还涉及将列表中的每个元素从包装类型 T 转换为普通类型 T。这是通过 swig 函数 SWIG_ConvertPtr.
- 我不确定您是否可以使用模板参数指定类型映射。因此，我编写了一个 swig 宏 %qlist_conversions(Type)，您可以使用它来将类型映射附加到特定 Type.
对于其他转换方向（QList -> python列表）你应该首先考虑你想要什么。考虑一个 return 是 QList<int> 的 C++ 函数。从 python 调用它，这个 return 应该是一个包装的 QList 对象，还是应该自动将 QList 转换为 python 列表？
将包装的 QList 作为 python 序列访问，即使 len 和 [] 从 python
为此，您需要使用 %extend { ... } 扩展 qlist.i 文件中的 QList class 并实现 __len__ 和 __getitem__ 方法。

如果切片也应该起作用，您需要为 PySliceObject 提供 __getitem__(PySliceObject *slice)__ 成员方法和输入以及 "typecheck" 类型映射。

如果您希望能够使用 python 中的 [] 修改包装 QList 中的值，您需要实施 __setitem__.

有关您可以实施以实现更好集成的所有有用方法的列表，请参阅有关 "builtin types" 和 "abstract base classes for containers" 的 python 文档。

注意：如果你使用swig -builtin功能，那么你需要额外注册上述功能到适当的"slots"使用例如
```
%feature("python:slot", "sq_length", functype="lenfunc") __len__;
```
使包装的 QList 可从 python
迭代为此，您需要扩展 QList class 并实现一个 __iter__() 方法，该方法 return 是一个 python 迭代器对象。

一个python迭代器对象是一个提供__iter__()和__next__()方法的对象（next()用于旧的python），其中__next__() return 下一个值并引发 python 异常 StopIteration 以表示结束。

如前所述，您可以在python或C++中实现迭代器对象。我在 python.

我希望这有助于作为调整所需功能的基础。

swig：如何使 QList<T> 可迭代，例如 std::vector

swig: How to make a QList<T> iterable, like std::vector

python

c++

qt

swig