python - 如何在无法访问 SWIG 模板的情况下向下转换 SWIG 对象？

Question

有没有办法动态向下转换 swig 对象的 swig 代理？

这样做的原因是为了模拟 C++ 向下转换，但纯粹来自 python。例如，典型的 C++ 用法是

MyBase* obj = new MyBase();    // eg might come via network
if (obj.is_child())            // runtime info lets us know what we are dealing with
{
    MyChild* child = (MyChild*) obj;
    obj->some_child_function();
}

在Python这边，MyBase和MyChild的代理对象是存在的，但是所有的对象都以MyBase类型进入python。我希望能够写:

obj = MyBase(); # eg might come from network
print(obj)
if obj.is_child():
    child_obj = MyChild.from_raw_ptr(obj.get_raw_ptr())  # Pseudo-code
    child_obj.some_child_function();
    print(obj)

Output like:
<MyBase; proxy of <Swig Object of type 'MyBase *' at 0x00000000069D46C0> >
<MyChild; proxy of <Swig Object of type 'MyChild *' at 0x00000000069D46C0> >

请注意，在示例输出中，两条输出线都引用相同的内存地址。

理想情况下，我想在纯 Python 中执行此操作，但如果它必须围绕某些 C/C++ 进行包装，请记住我无法访问 SWIG 模板或原始 C 代码。

Answer 1

让这个转换正常工作的棘手的一点不仅仅是改变代理的类型，你在你的答案中已经完成，而是改变代理内的 this 成员的类型正如您所认识到的，在您的问题的所需输出中也需要。

SWIG 确实存储了足够的信息来实现这一点，而且我能够相当简单地实现您想要的结果，而无需修补/重新编译/逆向工程/无论如何都依赖原始模块的 .i 文件，提供 您可以匹配用于构建它的 SWIG 版本和足够接近的编译器，以至于我们可以依赖内存中的结构布局相同。我应该警告这一点，我觉得我必须做的事情来解决它应该比必要的更复杂，但我看不到任何其他方式来公开 swig_type_info 中的类型层次信息是模块内部的，而不是像这样。

因此，为了验证和开发这一点，我将以下 test.i 文件放在一起，这是您遇到的问题的最小示例:

%module test

%inline %{

struct BaseClass {
    virtual bool is_derived() const { return false; }
    virtual ~BaseClass() {} 
};

struct DerivedClass : BaseClass {
    virtual bool is_derived() const { return true; }
    void do_something_special() {}
};

BaseClass *get_one() {
    static DerivedClass b;
    return &b;
};
%}

我编译这个:

swig3.0 -Wall -c++ -python test.i
g++ -Wall -Wextra -o _cast.so -shared -fPIC cast_wrap.cxx -I/usr/include/python2.7

但除了在我的代码中使用 import test 之外，我没有触及它。

如果我们查看生成的 test_wrap.cxx，我们可以看到 swig_type_info 的以下定义，它针对 SWIG 知道的每种类型发出一次:

/* Structure to store information on one type */
typedef struct swig_type_info {
  const char             *name;                 /* mangled name of this type */
  const char             *str;                  /* human readable name of this type */
  swig_dycast_func        dcast;                /* dynamic cast function down a hierarchy */
  struct swig_cast_info  *cast;                 /* linked list of types that can cast into this type */
  void                   *clientdata;           /* language specific type data */
  int                    owndata;               /* flag if the structure owns the clientdata */
} swig_type_info;

dcast 成员似乎没有被填充(即在我的测试中它总是空的)，但幸运的是 cast 成员被填充了。 cast 是指向类型层次结构信息链表中第一个节点的指针，如下所示:

/* Structure to store a type and conversion function used for casting */
typedef struct swig_cast_info {
  swig_type_info         *type;                 /* pointer to type that is equivalent to this type */
  swig_converter_func     converter;            /* function to cast the void pointers */
  struct swig_cast_info  *next;                 /* pointer to next cast in linked list */
  struct swig_cast_info  *prev;                 /* pointer to the previous cast */
} swig_cast_info;

其中包含类型名称和转换器函数。所以基本上我们需要做的是遍历链表来搜索执行我们之后的转换的转换器函数，然后调用它。此时您可能可以使用 ctypes 完全做到这一点，但是我选择利用完全相同的编译器和 SWIG 版本这一事实，这样我就不必用 ctypes 表示法来表达这些结构并且总是正确的，所以我只是写了另一个带有更多 C++ 的 SWIG 模块。

(我应该补充一点，在模块中确实有一些内部函数使用这些信息，但它们默认具有静态链接，因此在这里很难找到和使用它们)。

无论如何，我的 cast.i 文件将它整齐地暴露回 Python，最终看起来像这样:

%module cast

%{
#include <iostream>
%}

%inline %{
    PyObject *dyn_cast(PyObject *obj) {
        assert(SwigPyObject_Check(obj));
        SwigPyObject *s = (SwigPyObject*)obj;
        void *ptr = s->ptr;
        swig_cast_info *cast = s->ty->cast;
        while (cast) {
            std::cerr << "Cast @" << cast << ", converter: " << (void*)cast->converter << ", type: " << cast->type->str << "\n";
            if (0==strcmp(cast->type->name, "_p_DerivedClass")) break; 
            cast = cast->next;
        }
        assert(cast->converter);
        int newmem;
        s->ptr = cast->converter(ptr, &newmem);
        s->ty = cast->type;
        Py_INCREF(obj);
        return obj;
    }
%}

%pythoncode %{
import test

def base_to_derived(o):
    if not isinstance(o, test.BaseClass): raise TypeError()
    if not o.is_derived(): raise TypeError()
    c = test.DerivedClass.__new__(test.DerivedClass)
    c.this = dyn_cast(o.this)
    return c
%}

所做的只是遍历转换链表以查找有关派生类的信息。有一点额外的 Python 来安全地包装它并处理创建一个新的代理对象，但基本上就是这样。

有了这个，我就可以运行以下 Python 代码了:

import test

o=test.get_one()
print(o)

import cast

o=cast.base_to_derived(o)
print(o)
o.do_something_special()

编译我的 cast 模块后:

swig3.0 -Wall -c++ -python cast.i
g++ -Wall -Wextra -o _cast.so -shared -fPIC cast_wrap.cxx -I/usr/include/python2.7
python run.py 
<test.BaseClass; proxy of <Swig Object of type 'BaseClass *' at 0xb6cd9428> >
Cast @0xb6ccf5ec, converter: 0xb6cbcdf1, type: DerivedClass *
<test.DerivedClass; proxy of <Swig Object of type 'DerivedClass *' at 0xb6cd9428> >

就我个人而言，虽然我只是想维护原始模块的一个分支，向上游推送一个补丁，或者甚至只是使用 %import 编写另一个 SWIG 模块来扩展原始模块而不修改像这样。