blob: 95cc6859c738f137d5483c42e2a05c35966d53e3 (
plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
|
[section boost/python/manage_new_object.hpp]
[section Class `manage_new_object`]
`manage_new_object` is a model of [link concepts.resultconverter.resultconvertergenerator_concept ResultConverterGenerator] which can be used to wrap C++ functions which return a pointer to an object allocated with a new-expression, and expect the caller to take responsibility for deleting that object.
``
namespace boost { namespace python
{
struct manage_new_object
{
template <class T> struct apply;
};
}}
``
[endsect]
[section Class `manage_new_object` metafunctions]
``template <class T> struct apply``
[variablelist
[[Requires][`T` is `U*` for some `U`.]]
[[Returns][`typedef to_python_indirect<T> type;`]]
]
[endsect]
[section Example]
In C++:
``
#include <boost/python/module.hpp>
#include <boost/python/class.hpp>
#include <boost/python/manage_new_object.hpp>
#include <boost/python/return_value_policy.hpp>
struct Foo {
Foo(int x) : x(x){}
int get_x() { return x; }
int x;
};
Foo* make_foo(int x) { return new Foo(x); }
// Wrapper code
using namespace boost::python;
BOOST_PYTHON_MODULE(my_module)
{
def("make_foo", make_foo, return_value_policy<manage_new_object>())
class_<Foo>("Foo")
.def("get_x", &Foo::get_x)
;
}
``
Python code:
``
>>> from my_module import *
>>> f = make_foo(3) # create a Foo object
>>> f.get_x()
3
``
[endsect]
[endsect]
|
