python - SwigPyIterator 值始终是基类

Question

我在 C++ 中有 A、B、C 类。 B 和 C 派生自 A。我在 C++ 中有函数返回 B 和 C 的 vector :像 std::vector<A*> getAllObjects() .我使用 swig 生成 Python 包装器。然后我在 Python 中调用 getAllObjects() 如下:

objects = getAllObjects()
for obj in objects:
    if isinstance(obj, B):
        print("OK")
    elif isinstance(obj, C):
        print("OK")

我从迭代器中得到的对象是实例A，但它应该是B或C，如何解决问题？

Answer 1

你需要一些东西才能继续下去，而不仅仅是类型层次结构。通常在 Python/SWIG 场景中，以下其中一项就足够了:

1. 一个virtual基类中的函数(即 RTTI)
2. 一些成员变量或函数以某种方式标识给定实例的最派生类型(例如，C 中的常见模式是将结构的第一个字段包含为某种类型标识符)。
3. 对象创建时的某种 Hook ，例如，如果您知道所有实例都将由 Python 创建/拥有

我假设第一种类型就足够了，但即使对于其他情况也不难适应。

为了说明这一点，我编写了以下头文件:

class A {
public:
  virtual ~A() {}
};

class B : public A {
};

class C: public A {
};

给定这个头文件，在纯 C++ 中，我们可以使用 RTTI 执行以下操作:

#include "test.hh"
#include <typeinfo>
#include <iostream>

int main() {
  const auto& t1 = typeid(A);
  const auto& t2 = typeid(B);
  const auto& t3 = typeid(C);
  A *a = new A;
  A *b = new B;
  A *c = new C;
  const auto& at = typeid(*a);
  const auto& bt = typeid(*b);
  const auto& ct = typeid(*c);

  std::cout << t1.name() << "\n";
  std::cout << t2.name() << "\n";
  std::cout << t3.name() << "\n";
  std::cout << at.name() << "\n";
  std::cout << bt.name() << "\n";
  std::cout << ct.name() << "\n";
}

这说明我们试图解决的问题(它到底是什么类型？)实际上可以使用标准 C++ 解决。

此时值得注意的是，使用 std::vector 会使问题稍微复杂一些。迭代而不仅仅是一个返回单个 A* 的函数.如果我们只是处理函数的返回值，我们会写一个 typemap(out) .在 std::vector<A*> 的情况下然而，可以自定义迭代返回的行为并插入额外的代码以确保 Python 知道派生类型而不仅仅是基类。 SWIG 有一个类型特征机制，大多数标准容器都使用该机制来帮助它们进行常见用途(例如迭代)，而不会出现过多的重复。 (作为引用，我认为这是在 std_common.i 中)。

因此，基本计划是使用 SWIG 引入的特征类型来自定义迭代过程的输出( SwigPyIterator ，在本例中实现为 SwigPyIteratorClosed_T)。在那个钩子(Hook)里面，而不是盲目地使用 A* 的 SWIG 类型信息我们将使用 typeid在 std::map 中动态查找类型.该映射在模块内部维护。如果我们在该映射中找到任何东西，我们将使用它返回一个更派生的 Python 对象，正如 Python 程序员所期望的那样。最后，我们需要在初始化时在映射中注册类型。

所以我的界面最终看起来像这样:

%module test

%{
#include "test.hh"
#include <vector>
#include <map>
#include <string>
#include <typeindex> // C++11! - see: http://stackoverflow.com/a/9859605/168175
%}

%include <std_vector.i>

%{
namespace {
  // Internal only, store the type mappings
  std::map<std::type_index, swig_type_info*> aheirarchy;
}

namespace swig {
  // Forward declare traits, the fragments they're from won't be there yet
  template <class Type> struct traits_from_ptr;
  template <class Type>
  inline swig_type_info *type_info();

  template <> struct traits_from_ptr<A> {
    static PyObject *from(A *val, int owner = 0) {
      auto ty = aheirarchy[typeid(*val)];
      if (!ty) {
        // if there's nothing in the map, do what SWIG would have done
        ty = type_info<A>();
      }
      return SWIG_NewPointerObj(val, ty, owner);
    }
  };
}
%}

%template(AList) std::vector<A*>;

%inline %{
const std::vector<A*>& getAllObjects() {
  // Demo only
  static auto ret = std::vector<A*>{new A, new B, new C, new C, new B};
  return ret;
}
%}

%include "test.hh"
%init %{
  // Register B and C here
  aheirarchy[typeid(B)] = SWIG_TypeQuery("B*");
  aheirarchy[typeid(C)] = SWIG_TypeQuery("C*");
%}

随着 %inline我写的函数只是为了说明足以让事情开始的事情。它允许我运行以下测试 Python 来演示我的解决方案:

from test import getAllObjects, A, B, C

objects = getAllObjects()
for obj in objects:
    print obj
    if isinstance(obj, B):
        print("OK")
    elif isinstance(obj, C):
        print("OK")

swig3.0 -c++ -python -Wall test.i
g++ -std=c++11 -Wall test_wrap.cxx -o  _test.so -shared -I/usr/include/python2.7/ -fPIC
python run.py 
<test.A; proxy of <Swig Object of type 'A *' at 0xf7442950> >
<test.B; proxy of <Swig Object of type 'B *' at 0xf7442980> >
OK
<test.C; proxy of <Swig Object of type 'C *' at 0xf7442fb0> >
OK
<test.C; proxy of <Swig Object of type 'C *' at 0xf7442fc8> >
OK
<test.B; proxy of <Swig Object of type 'B *' at 0xf7442f98> >
OK

您会注意到它与我在 getAllObjects 的虚拟实现中创建的类型相匹配.

你可以更巧妙地做一些事情:

1. 添加一个用于注册类型的宏。 (或者以其他方式自动执行)
2. 如果需要，添加用于定期返回对象的类型映射。

正如我之前指出的，这不是解决此问题的唯一方法，只是最通用的方法。