添加 swig pythoncode 以在 Python 对象上设置 thisown 标志
Adding swig pythoncode to set thisown flag on Python object
我有一个 swigged C++ class 容器，MyContainer，持有 MyObject 类型的对象，也是一个 C++ class.
以下为C++头代码(freemenot.h)
#ifndef freemenotH
#define freemenotH
#include <vector>
#include <string>
using std::string;
class MyObject
{
public:
MyObject(const string& lbl);
~MyObject();
string getLabel();
private:
string label;
};
class MyContainer
{
public:
MyContainer();
~MyContainer();
void addObject(MyObject* o);
MyObject* getObject(unsigned int t);
int getNrOfObjects();
private:
std::vector<MyObject*> mObjects;
};
#endif
这是来源 (freemenot.cpp)
#include "freemenot.h"
#include <iostream>
using namespace std;
/* MyObject source */
MyObject::MyObject(const string& lbl)
:
label(lbl)
{ cout<<"In object ctor"<<endl; }
MyObject::~MyObject() { cout<<"In object dtor"<<endl; }
string MyObject::getLabel() { return label; }
/* MyContainer source */
MyContainer::MyContainer() { cout<<"In container ctor"<<endl; }
MyContainer::~MyContainer()
{
cout<<"In container dtor"<<endl;
for(unsigned int i = 0; i < mObjects.size(); i++)
{
delete mObjects[i];
}
}
int MyContainer::getNrOfObjects() { return mObjects.size(); }
void MyContainer::addObject(MyObject* o) { mObjects.push_back(o); }
MyObject* MyContainer::getObject(unsigned int i) { return mObjects[i]; }
观察对象在向量中存储为 RAW POINTERS。 class 就是这样设计的，因此容器负责释放其析构函数中的对象，就像在析构函数 for 循环中所做的那样。
在 C++ 代码中，如下所示，将对象 o1 添加到容器 c，返回给客户端代码
MyContainer* getAContainerWithSomeObjects()
{
MyContainer* c = new MyContainer();
MyObject* o1 = new MyObject();
c.add(o1);
return c;
}
返回的容器拥有它的对象，并负责在完成后释放这些对象。在 C++ 中，可以在上述函数退出后访问容器对象。
使用 Swig 将上述 classes 暴露给 python，将需要一个接口文件。这个接口文件看起来像这样
%module freemenot
%{ #include "freemenot.h" %}
%include "std_string.i"
//Expose to Python
%include "freemenot.h"
并使用 CMake 生成 Python 模块，使用了以下 CMake 脚本。
cmake_minimum_required(VERSION 2.8)
project(freemenot)
find_package(SWIG REQUIRED)
include(UseSWIG)
find_package(PythonInterp)
find_package(PythonLibs)
get_filename_component(PYTHON_LIB_FOLDER ${PYTHON_LIBRARIES} DIRECTORY CACHE)
message("Python lib folder: " ${PYTHON_LIB_FOLDER})
message("Python include folder: " ${PYTHON_INCLUDE_DIRS})
message("Python libraries: " ${PYTHON_LIBRARIES})
set(PyModule "freemenot")
include_directories(
${PYTHON_INCLUDE_PATH}
${CMAKE_CURRENT_SOURCE_DIR}
)
link_directories( ${PYTHON_LIB_FOLDER})
set(CMAKE_MODULE_LINKER_FLAGS ${CMAKE_CURRENT_SOURCE_DIR}/${PyModule}.def)
set_source_files_properties(${PyModule}.i PROPERTIES CPLUSPLUS ON)
set_source_files_properties(${PyModule}.i PROPERTIES SWIG_FLAGS "-threads")
SWIG_ADD_LIBRARY(${PyModule}
MODULE LANGUAGE python
SOURCES ${PyModule}.i freemenot.cpp)
SWIG_LINK_LIBRARIES (${PyModule} ${PYTHON_LIB_FOLDER}/Python37_CG.lib )
# INSTALL PYTHON BINDINGS
# Get the python site packages directory by invoking python
execute_process(COMMAND python -c "import site; print(site.getsitepackages()[0])" OUTPUT_VARIABLE PYTHON_SITE_PACKAGES OUTPUT_STRIP_TRAILING_WHITESPACE)
message("PYTHON_SITE_PACKAGES = ${PYTHON_SITE_PACKAGES}")
install(
TARGETS _${PyModule}
DESTINATION ${PYTHON_SITE_PACKAGES})
install(
FILES ${CMAKE_CURRENT_BINARY_DIR}/${PyModule}.py
DESTINATION ${PYTHON_SITE_PACKAGES}
)
使用 CMake 生成 make 文件，并使用 borlands bcc32 编译器编译，生成一个 Python 模块 (freemenot) 并安装到 python 3 个有效的站点包文件夹。
那么，在Python中，可以用下面的脚本来说明问题
import freemenot as fmn
def getContainer():
c = fmn.MyContainer()
o1 = fmn.MyObject("This is a label")
o1.thisown = 0
c.addObject(o1)
return c
c = getContainer()
print (c.getNrOfObjects())
#if the thisown flag for objects in the getContainer function
#is equal to 1, the following call return an undefined object
#If the flag is equal to 0, the following call will return a valid object
a = c.getObject(0)
print (a.getLabel())
此 Python 代码可能看起来不错，但 无法正常工作 。问题是，当函数 getContainer() returns、对象 o1 的内存被释放时，如果 thisown 标志没有设置为零。访问此行之后的对象，使用返回的容器将以灾难告终。观察一下，这本身并没有什么问题，因为这就是 pythons 垃圾收集的工作方式。
对于能够设置 python 对象 thisown 标志 inside addObject 函数的上述用例，将呈现Python 中可用的 C++ 对象。
让用户设置此标志不是好的解决方案。
还可以使用 "addObject" 函数扩展 python class，并修改此函数内的 thisown 标志，从而对用户隐藏此记忆技巧。
问题是，如何让 Swig 在不扩展 class 的情况下执行此操作？
我正在寻找使用 typemap，或者 %pythoncode，但我似乎无法找到一个好的工作示例.
以上代码将由调用 Python 解释器的 C++ 程序使用并传递给该程序。 C++ 程序负责管理在 python 函数中分配的内存，即使在 PyFinalize() 之后也是如此。
以上代码可以在githubhttps://github.com/TotteKarlsson/miniprojects
下载
您正在寻找 %newobject。这是一个小例子：
%module test
%newobject create;
%delobject destroy;
%inline %{
#include <iostream>
struct Test
{
Test() { std::cout << "create" << std::endl; }
~Test() { std::cout << "destroy" << std::endl; }
};
Test* create() { return new Test; }
void destroy(Test* t) { delete t; }
%}
使用：
>>> import test
>>> t1 = test.create() # create a test object
create
>>> t2 = test.Test() # don't really need a create function :)
create
>>> t3 = test.create() # and another.
create
>>> test.destroy(t2) # explicitly destroy one
destroy
>>>
>>>
>>>
>>> ^Z # exit Python and the other two get destroyed.
destroy
destroy
有许多不同的方法可以解决这个问题，所以我将尝试依次解释它们，并在此过程中建立一些东西。希望这有助于了解 SWIG 的选项和内部结构，即使您真的只需要第一个示例。
添加Python代码直接修改thisown
最像您提出的解决方案依赖于使用 SWIG 的 %pythonprepend 指令添加一些额外的 Python 代码。您可以根据您关心的重载的 C++ 声明来定位它，例如：
%module freemenot
%{ #include "freemenot.h" %}
%include "std_string.i"
%pythonprepend MyContainer::addObject(MyObject*) %{
# mess with thisown
print('thisown was: %d' % args[0].thisown)
args[0].thisown = 0
%}
//Expose to Python
%include "freemenot.h"
唯一值得注意的怪癖是参数是使用 *args 而不是命名参数传递的，因此我们必须通过位置编号访问它。
还有其他几个 places/methods 可以在 SWIG Python documentation 中注入额外的 Python 代码（前提是你没有使用 -builtin）并且猴子补丁总是一个选项也是。
使用 Python 的 C API 调整 thisown
这里的下一个可能选项是使用类型映射调用 Python C API 来执行等效功能。在这种情况下，我匹配了参数类型 和 参数名称，但这确实意味着此处的类型映射将应用于所有接收名为 [=21] 的 MyObject * 的函数=]. （这里最简单的解决方案是让名称描述 headers 中的预期语义，如果这样的话 over-match 目前这具有使 IDE 和文档更清晰的附带好处）。
%module freemenot
%{ #include "freemenot.h" %}
%include "std_string.i"
%typemap(in) MyObject *o {
PyObject_SetAttrString($input, "thisown", PyInt_FromLong(0)); // As above, but C API
$typemap(in,MyObject*); // use the default typemap
}
//Expose to Python
%include "freemenot.h"
除了类型映射匹配之外，这个例子最值得注意的一点是这里使用 $typemap 到 'paste' 另一个类型映射，特别是 MyObject* 的默认类型到我们自己的类型映射.值得在 before/after 示例中查看生成的包装文件，了解最终的样子。
使用 SWIG 运行时直接获取 SwigPyObject 结构的 own 成员
由于我们已经在编写 C++ 而不是通过 Python 代码中的 setattr 我们可以调整此类型映射以使用更多 SWIG 的内部结构并跳过 round-trip C 到 Python 然后再回到 C。
在 SWIG 内部，有一个结构包含每个实例的详细信息，包括所有权、类型等。
我们可以自己直接从 PyObject* 转换为 SwigPyObject*，但这需要我们自己编写错误 handling/type 检查（这个 PyObject 甚至是 SWIG 对象吗？）并变得依赖关于 SWIG 可以生成 Python 接口的各种不同方式的详细信息。相反，我们可以调用一个函数来为我们处理所有这些，因此我们现在可以像这样编写类型映射：
%module freemenot
%{ #include "freemenot.h" %}
%include "std_string.i"
%typemap(in) MyObject *o {
// TODO: handle NULL pointer still
SWIG_Python_GetSwigThis($input)->own = 0; // Safely cast $input from PyObject* to SwigPyObject*
$typemap(in,MyObject*); // use the default typemap
}
//Expose to Python
%include "freemenot.h"
这实际上只是先前答案的演变，但纯粹在 SWIG C 运行时中实现。
在添加之前复制构造一个新实例
还有其他方法可以解决此类所有权问题。首先，在这个特定的实例中，你的 MyContainer 假设它总是可以在它存储的每个实例上调用 delete（因此拥有这些语义）。
如果我们也像这样包装一个函数，那么激发灵感的例子就是：
MyObject *getInstanceOfThing() {
static MyObject a;
return &a;
}
这给我们之前的解决方案引入了一个问题——我们将 thisown 设置为 0，但在这里它已经是 0，所以我们仍然不能合法地在指针上调用 delete容器已释放。
有一种简单的方法可以解决这个问题，不需要了解 SWIG 代理内部 - 假设 MyObject 是可复制构造的，那么您可以简单地创建一个新实例并确保无论它来自哪里从容器中删除它是合法的。我们可以通过稍微调整我们的类型图来做到这一点：
%module freemenot
%{ #include "freemenot.h" %}
%include "std_string.i"
%typemap(in) MyObject *o {
$typemap(in,MyObject*); // use the default typemap as before
= new $*1_type(*); // but afterwards call copy-ctor
}
//Expose to Python
%include "freemenot.h"
这里要注意的一点是使用了更多的 SWIG 功能，这些功能让我们知道类型映射输入的类型 - $*1_type 是被取消引用一次的类型映射参数的类型。我们可以在这里写 MyObject，因为这就是它的解析结果，但是如果您的容器确实是模板，这可以让您处理诸如模板之类的事情，或者 re-use 其他类似容器中的类型映射 %apply.
现在要注意的是泄漏，如果你有一个 C++ 函数，你故意允许 return 一个没有设置 thisown 的实例，假设容器将获得所有权那现在不成立了。
让容器有机会管理所有权
最后，我很喜欢使用的其他技术之一在当前提出的情况下无法直接在此处使用，但值得为后代提及。如果你有机会在容器中的每个实例旁边存储一些额外的数据，你可以调用 Py_INCREF 并保留对基础 PyObject* 的引用，无论它来自哪里。如果您随后在销毁时获得回调，您还可以调用 Py_DECREF 并强制 Python 运行时保持 object 与容器一样长。
即使无法保持 1-1，您也可以这样做 MyObject*PyObject* 通过在某处也保持影子容器存活来配对存活。这可能很难做到，除非您愿意将另一个 object 添加到容器中，将其子类化，或者可以非常确定容器的初始 Python 实例将始终存在足够长的时间。
我有一个 swigged C++ class 容器，MyContainer，持有 MyObject 类型的对象，也是一个 C++ class.
以下为C++头代码(freemenot.h)
#ifndef freemenotH
#define freemenotH
#include <vector>
#include <string>
using std::string;
class MyObject
{
public:
MyObject(const string& lbl);
~MyObject();
string getLabel();
private:
string label;
};
class MyContainer
{
public:
MyContainer();
~MyContainer();
void addObject(MyObject* o);
MyObject* getObject(unsigned int t);
int getNrOfObjects();
private:
std::vector<MyObject*> mObjects;
};
#endif
这是来源 (freemenot.cpp)
#include "freemenot.h"
#include <iostream>
using namespace std;
/* MyObject source */
MyObject::MyObject(const string& lbl)
:
label(lbl)
{ cout<<"In object ctor"<<endl; }
MyObject::~MyObject() { cout<<"In object dtor"<<endl; }
string MyObject::getLabel() { return label; }
/* MyContainer source */
MyContainer::MyContainer() { cout<<"In container ctor"<<endl; }
MyContainer::~MyContainer()
{
cout<<"In container dtor"<<endl;
for(unsigned int i = 0; i < mObjects.size(); i++)
{
delete mObjects[i];
}
}
int MyContainer::getNrOfObjects() { return mObjects.size(); }
void MyContainer::addObject(MyObject* o) { mObjects.push_back(o); }
MyObject* MyContainer::getObject(unsigned int i) { return mObjects[i]; }
观察对象在向量中存储为 RAW POINTERS。 class 就是这样设计的，因此容器负责释放其析构函数中的对象，就像在析构函数 for 循环中所做的那样。
在 C++ 代码中，如下所示，将对象 o1 添加到容器 c，返回给客户端代码
MyContainer* getAContainerWithSomeObjects()
{
MyContainer* c = new MyContainer();
MyObject* o1 = new MyObject();
c.add(o1);
return c;
}
返回的容器拥有它的对象，并负责在完成后释放这些对象。在 C++ 中，可以在上述函数退出后访问容器对象。
使用 Swig 将上述 classes 暴露给 python，将需要一个接口文件。这个接口文件看起来像这样
%module freemenot
%{ #include "freemenot.h" %}
%include "std_string.i"
//Expose to Python
%include "freemenot.h"
并使用 CMake 生成 Python 模块，使用了以下 CMake 脚本。
cmake_minimum_required(VERSION 2.8)
project(freemenot)
find_package(SWIG REQUIRED)
include(UseSWIG)
find_package(PythonInterp)
find_package(PythonLibs)
get_filename_component(PYTHON_LIB_FOLDER ${PYTHON_LIBRARIES} DIRECTORY CACHE)
message("Python lib folder: " ${PYTHON_LIB_FOLDER})
message("Python include folder: " ${PYTHON_INCLUDE_DIRS})
message("Python libraries: " ${PYTHON_LIBRARIES})
set(PyModule "freemenot")
include_directories(
${PYTHON_INCLUDE_PATH}
${CMAKE_CURRENT_SOURCE_DIR}
)
link_directories( ${PYTHON_LIB_FOLDER})
set(CMAKE_MODULE_LINKER_FLAGS ${CMAKE_CURRENT_SOURCE_DIR}/${PyModule}.def)
set_source_files_properties(${PyModule}.i PROPERTIES CPLUSPLUS ON)
set_source_files_properties(${PyModule}.i PROPERTIES SWIG_FLAGS "-threads")
SWIG_ADD_LIBRARY(${PyModule}
MODULE LANGUAGE python
SOURCES ${PyModule}.i freemenot.cpp)
SWIG_LINK_LIBRARIES (${PyModule} ${PYTHON_LIB_FOLDER}/Python37_CG.lib )
# INSTALL PYTHON BINDINGS
# Get the python site packages directory by invoking python
execute_process(COMMAND python -c "import site; print(site.getsitepackages()[0])" OUTPUT_VARIABLE PYTHON_SITE_PACKAGES OUTPUT_STRIP_TRAILING_WHITESPACE)
message("PYTHON_SITE_PACKAGES = ${PYTHON_SITE_PACKAGES}")
install(
TARGETS _${PyModule}
DESTINATION ${PYTHON_SITE_PACKAGES})
install(
FILES ${CMAKE_CURRENT_BINARY_DIR}/${PyModule}.py
DESTINATION ${PYTHON_SITE_PACKAGES}
)
使用 CMake 生成 make 文件，并使用 borlands bcc32 编译器编译，生成一个 Python 模块 (freemenot) 并安装到 python 3 个有效的站点包文件夹。
那么，在Python中，可以用下面的脚本来说明问题
import freemenot as fmn
def getContainer():
c = fmn.MyContainer()
o1 = fmn.MyObject("This is a label")
o1.thisown = 0
c.addObject(o1)
return c
c = getContainer()
print (c.getNrOfObjects())
#if the thisown flag for objects in the getContainer function
#is equal to 1, the following call return an undefined object
#If the flag is equal to 0, the following call will return a valid object
a = c.getObject(0)
print (a.getLabel())
此 Python 代码可能看起来不错，但 无法正常工作 。问题是，当函数 getContainer() returns、对象 o1 的内存被释放时，如果 thisown 标志没有设置为零。访问此行之后的对象，使用返回的容器将以灾难告终。观察一下，这本身并没有什么问题，因为这就是 pythons 垃圾收集的工作方式。
对于能够设置 python 对象 thisown 标志 inside addObject 函数的上述用例，将呈现Python 中可用的 C++ 对象。 让用户设置此标志不是好的解决方案。 还可以使用 "addObject" 函数扩展 python class，并修改此函数内的 thisown 标志，从而对用户隐藏此记忆技巧。
问题是，如何让 Swig 在不扩展 class 的情况下执行此操作？ 我正在寻找使用 typemap，或者 %pythoncode，但我似乎无法找到一个好的工作示例.
以上代码将由调用 Python 解释器的 C++ 程序使用并传递给该程序。 C++ 程序负责管理在 python 函数中分配的内存，即使在 PyFinalize() 之后也是如此。
以上代码可以在githubhttps://github.com/TotteKarlsson/miniprojects
下载您正在寻找 %newobject。这是一个小例子：
%module test
%newobject create;
%delobject destroy;
%inline %{
#include <iostream>
struct Test
{
Test() { std::cout << "create" << std::endl; }
~Test() { std::cout << "destroy" << std::endl; }
};
Test* create() { return new Test; }
void destroy(Test* t) { delete t; }
%}
使用：
>>> import test
>>> t1 = test.create() # create a test object
create
>>> t2 = test.Test() # don't really need a create function :)
create
>>> t3 = test.create() # and another.
create
>>> test.destroy(t2) # explicitly destroy one
destroy
>>>
>>>
>>>
>>> ^Z # exit Python and the other two get destroyed.
destroy
destroy
有许多不同的方法可以解决这个问题，所以我将尝试依次解释它们，并在此过程中建立一些东西。希望这有助于了解 SWIG 的选项和内部结构，即使您真的只需要第一个示例。
添加Python代码直接修改thisown
最像您提出的解决方案依赖于使用 SWIG 的 %pythonprepend 指令添加一些额外的 Python 代码。您可以根据您关心的重载的 C++ 声明来定位它，例如：
%module freemenot
%{ #include "freemenot.h" %}
%include "std_string.i"
%pythonprepend MyContainer::addObject(MyObject*) %{
# mess with thisown
print('thisown was: %d' % args[0].thisown)
args[0].thisown = 0
%}
//Expose to Python
%include "freemenot.h"
唯一值得注意的怪癖是参数是使用 *args 而不是命名参数传递的，因此我们必须通过位置编号访问它。
还有其他几个 places/methods 可以在 SWIG Python documentation 中注入额外的 Python 代码（前提是你没有使用 -builtin）并且猴子补丁总是一个选项也是。
使用 Python 的 C API 调整 thisown
这里的下一个可能选项是使用类型映射调用 Python C API 来执行等效功能。在这种情况下，我匹配了参数类型 和 参数名称，但这确实意味着此处的类型映射将应用于所有接收名为 [=21] 的 MyObject * 的函数=]. （这里最简单的解决方案是让名称描述 headers 中的预期语义，如果这样的话 over-match 目前这具有使 IDE 和文档更清晰的附带好处）。
%module freemenot
%{ #include "freemenot.h" %}
%include "std_string.i"
%typemap(in) MyObject *o {
PyObject_SetAttrString($input, "thisown", PyInt_FromLong(0)); // As above, but C API
$typemap(in,MyObject*); // use the default typemap
}
//Expose to Python
%include "freemenot.h"
除了类型映射匹配之外，这个例子最值得注意的一点是这里使用 $typemap 到 'paste' 另一个类型映射，特别是 MyObject* 的默认类型到我们自己的类型映射.值得在 before/after 示例中查看生成的包装文件，了解最终的样子。
使用 SWIG 运行时直接获取 SwigPyObject 结构的 own 成员
由于我们已经在编写 C++ 而不是通过 Python 代码中的 setattr 我们可以调整此类型映射以使用更多 SWIG 的内部结构并跳过 round-trip C 到 Python 然后再回到 C。
在 SWIG 内部，有一个结构包含每个实例的详细信息，包括所有权、类型等。
我们可以自己直接从 PyObject* 转换为 SwigPyObject*，但这需要我们自己编写错误 handling/type 检查（这个 PyObject 甚至是 SWIG 对象吗？）并变得依赖关于 SWIG 可以生成 Python 接口的各种不同方式的详细信息。相反，我们可以调用一个函数来为我们处理所有这些，因此我们现在可以像这样编写类型映射：
%module freemenot
%{ #include "freemenot.h" %}
%include "std_string.i"
%typemap(in) MyObject *o {
// TODO: handle NULL pointer still
SWIG_Python_GetSwigThis($input)->own = 0; // Safely cast $input from PyObject* to SwigPyObject*
$typemap(in,MyObject*); // use the default typemap
}
//Expose to Python
%include "freemenot.h"
这实际上只是先前答案的演变，但纯粹在 SWIG C 运行时中实现。
在添加之前复制构造一个新实例
还有其他方法可以解决此类所有权问题。首先，在这个特定的实例中，你的 MyContainer 假设它总是可以在它存储的每个实例上调用 delete（因此拥有这些语义）。
如果我们也像这样包装一个函数，那么激发灵感的例子就是：
MyObject *getInstanceOfThing() {
static MyObject a;
return &a;
}
这给我们之前的解决方案引入了一个问题——我们将 thisown 设置为 0，但在这里它已经是 0，所以我们仍然不能合法地在指针上调用 delete容器已释放。
有一种简单的方法可以解决这个问题，不需要了解 SWIG 代理内部 - 假设 MyObject 是可复制构造的，那么您可以简单地创建一个新实例并确保无论它来自哪里从容器中删除它是合法的。我们可以通过稍微调整我们的类型图来做到这一点：
%module freemenot
%{ #include "freemenot.h" %}
%include "std_string.i"
%typemap(in) MyObject *o {
$typemap(in,MyObject*); // use the default typemap as before
= new $*1_type(*); // but afterwards call copy-ctor
}
//Expose to Python
%include "freemenot.h"
这里要注意的一点是使用了更多的 SWIG 功能，这些功能让我们知道类型映射输入的类型 - $*1_type 是被取消引用一次的类型映射参数的类型。我们可以在这里写 MyObject，因为这就是它的解析结果，但是如果您的容器确实是模板，这可以让您处理诸如模板之类的事情，或者 re-use 其他类似容器中的类型映射 %apply.
现在要注意的是泄漏，如果你有一个 C++ 函数，你故意允许 return 一个没有设置 thisown 的实例，假设容器将获得所有权那现在不成立了。
让容器有机会管理所有权
最后，我很喜欢使用的其他技术之一在当前提出的情况下无法直接在此处使用，但值得为后代提及。如果你有机会在容器中的每个实例旁边存储一些额外的数据，你可以调用 Py_INCREF 并保留对基础 PyObject* 的引用，无论它来自哪里。如果您随后在销毁时获得回调，您还可以调用 Py_DECREF 并强制 Python 运行时保持 object 与容器一样长。
即使无法保持 1-1，您也可以这样做 MyObject*PyObject* 通过在某处也保持影子容器存活来配对存活。这可能很难做到，除非您愿意将另一个 object 添加到容器中，将其子类化，或者可以非常确定容器的初始 Python 实例将始终存在足够长的时间。