def my_module_gen(out_file):
mod = Module('c')
mod.add_include('"c.h"')
mod.add_function("GetBuffer", BufferReturn("unsigned short int*", "GetBufferLen()"), [])
mod.add_function("GetBufferLen", ReturnValue.new("int"), [])
mod.add_function("GetBufferChecksum", ReturnValue.new("unsigned short"), [])
mod.generate(FileCodeSink(out_file))
def my_module_gen(out_file):
mod = Module('c')
mod.add_include('"c.h"')
mod.add_function("GetBuffer",
BufferReturn("unsigned short int*", "GetBufferLen()"), [])
mod.add_function("GetBufferLen", ReturnValue.new("int"), [])
mod.add_function("GetBufferChecksum", ReturnValue.new("unsigned short"),
[])
mod.generate(FileCodeSink(out_file))
def my_module_gen(out_file):
mod = Module('bar')
mod.add_include('"bar.h"')
Foo = mod.add_class('Foo',
automatic_type_narrowing=True,
memory_policy=cppclass.BoostSharedPtr('::Foo'))
Foo.add_static_attribute('instance_count', ReturnValue.new('int'))
Foo.add_constructor([Parameter.new('std::string', 'datum')])
Foo.add_constructor([])
Foo.add_method('get_datum', ReturnValue.new('const std::string'), [])
Foo.add_method('is_initialized',
ReturnValue.new('bool'), [],
is_const=True)
Foo.add_output_stream_operator()
mod.add_function('function_that_takes_foo', ReturnValue.new('void'),
[param('boost::shared_ptr<Foo>', 'foo')])
mod.add_function('function_that_returns_foo',
retval('boost::shared_ptr<Foo>'), [])
cls = mod.add_class('ClassThatTakesFoo', allow_subclassing=True)
cls.add_constructor([Parameter.new('boost::shared_ptr<Foo>', 'foo')])
cls.add_method('get_foo', ReturnValue.new('boost::shared_ptr<Foo>'), [])
cls.add_method('get_modified_foo',
retval('boost::shared_ptr<Foo>'),
[param('boost::shared_ptr<Foo>', 'foo')],
is_virtual=True,
is_const=True)
#### --- error handler ---
class MyErrorHandler(pybindgen.settings.ErrorHandler):
def __init__(self):
super(MyErrorHandler, self).__init__()
self.num_errors = 0
def handle_error(self, wrapper, exception, traceback_):
print >> sys.stderr, "exception %s in wrapper %s" % (exception,
wrapper)
self.num_errors += 1
if 0: # verbose?
import traceback
traceback.print_tb(traceback_)
return True
pybindgen.settings.error_handler = MyErrorHandler()
## ---- finally, generate the whole thing ----
mod.generate(FileCodeSink(out_file))
def my_module_gen(out_file):
mod = Module('b')
mod.add_include('"b.h"')
B = mod.add_class('B')
B.add_constructor([])
B.add_instance_attribute('b_a', ReturnValue.new('uint32_t'))
B.add_instance_attribute('b_b', ReturnValue.new('uint32_t'))
mod.add_function('BDoA', None, [Parameter.new('B', 'b')])
mod.add_function('BDoB', ReturnValue.new('B'), [])
mod.generate(FileCodeSink(out_file) )
def register_Tr_info_methods(root_module, cls):
cls.add_instance_attribute('comment', 'char *', is_const=True)
cls.add_instance_attribute('creator', 'char *', is_const=True)
cls.add_instance_attribute('dateCreated', 'time_t', is_const=True,
custom_name='date_created')
cls.add_instance_attribute('fileCount', 'tr_file_index_t', is_const=True,
custom_name='file_count')
cls.add_instance_attribute('files',
ReturnValue.new('tr_file **',
array_length="self->obj->fileCount",
caller_owns_return=False),
is_const=True)
cls.add_instance_attribute('hash',
ReturnValue.new('uint8_t *',
is_const=True,
array_length=SHA_DIGEST_LENGTH),
is_const=True)
cls.add_instance_attribute('hashString', 'char *', is_const=True,
custom_name='hash_string')
cls.add_instance_attribute('isMultifile', 'bool', is_const=True,
custom_name='multifile')
cls.add_instance_attribute('isPrivate', 'bool', is_const=True,
custom_name='private')
cls.add_instance_attribute('name', 'char *', is_const=True)
cls.add_instance_attribute('pieceCount', 'tr_piece_index_t', is_const=True,
custom_name='piece_count')
cls.add_instance_attribute('pieceSize', 'uint32_t', is_const=True,
custom_name='piece_size')
cls.add_instance_attribute('pieces',
ReturnValue.new('tr_piece **',
array_length="self->obj->pieceCount",
caller_owns_return=False),
is_const=True)
cls.add_instance_attribute('torrent', 'char *', is_const=True)
cls.add_instance_attribute('totalSize', 'uint64_t', is_const=True,
custom_name='total_size')
cls.add_instance_attribute('trackerCount', 'int', is_const=True,
custom_name='tracker_count')
cls.add_instance_attribute('trackers',
ReturnValue.new('tr_tracker_info **',
array_length="self->obj->trackerCount",
caller_owns_return=False),
is_const=True)
cls.add_instance_attribute('webseedCount', 'int', is_const=True,
custom_name='webseed_count')
cls.add_instance_attribute('webseeds',
ReturnValue.new('char **', array_length="self->obj->webseedCount"),
is_const=True)
return
def my_module_gen(out_file):
mod = Module('d')
mod.add_include('"d.h"')
D = mod.add_class('D', memory_policy=cppclass.FreeFunctionPolicy('DDestroy'))
D.add_instance_attribute('d', ReturnValue.new('bool'))
D.add_function_as_constructor("DCreate", ReturnValue.new("D*", caller_owns_return=True), [])
mod.add_function('DDoA', None, [Parameter.new('D*', 'd', transfer_ownership=False)])
mod.add_function('DDoB', None, [Parameter.new('D&', 'd', direction=Parameter.DIRECTION_IN)])
mod.add_function('DDoC', None, [Parameter.new('const D&', 'd',
direction=Parameter.DIRECTION_IN)])
mod.generate(FileCodeSink(out_file) )
def my_module_gen(out_file):
mod = Module('e')
mod.add_include('"e.h"')
E = mod.add_class('E', memory_policy=cppclass.ReferenceCountingMethodsPolicy(decref_method='Unref', incref_method='Ref'))
if 1:
E.add_function_as_constructor("E::CreateWithRef", ReturnValue.new("E*", caller_owns_return=True), [])
else:
## alternative:
E.add_function_as_constructor("E::CreateWithoutRef", ReturnValue.new("E*", caller_owns_return=False), [])
E.add_method("Do", None, [])
mod.generate(FileCodeSink(out_file) )
def my_module_gen(out_file):
mod = Module('b')
mod.add_include('"b.h"')
B = mod.add_class('B')
B.add_constructor([])
B.add_copy_constructor()
B.add_instance_attribute('b_a', ReturnValue.new('uint32_t'))
B.add_instance_attribute('b_b', ReturnValue.new('uint32_t'))
mod.add_function('BDoA', None, [Parameter.new('B', 'b')])
mod.add_function('BDoB', ReturnValue.new('B'), [])
mod.generate(FileCodeSink(out_file) )
def register_Tr_piece_methods(root_module, cls):
cls.add_instance_attribute('timeChecked', 'time_t', is_const=True, custom_name='time_checked')
cls.add_instance_attribute('hash',
ReturnValue.new('uint8_t *', array_length=SHA_DIGEST_LENGTH),
is_const=True)
cls.add_instance_attribute('priority', 'int8_t', is_const=True)
cls.add_instance_attribute('dnd', 'bool', is_const=True, custom_name='do_not_download')
return
def my_module_gen(out_file):
mod = Module('bar')
mod.add_include ('"bar.h"')
Foo = mod.add_class('Foo', automatic_type_narrowing=True,
memory_policy=BoostSharedPtr('::Foo'))
Foo.add_static_attribute('instance_count', ReturnValue.new('int'))
Foo.add_constructor([Parameter.new('std::string', 'datum')])
Foo.add_constructor([])
Foo.add_method('get_datum', ReturnValue.new('const std::string'), [])
Foo.add_method('is_initialized', ReturnValue.new('bool'), [], is_const=True)
Foo.add_output_stream_operator()
mod.add_function('function_that_takes_foo', ReturnValue.new('void'),
[param('boost::shared_ptr<Foo>', 'foo')])
mod.add_function('function_that_returns_foo', retval('boost::shared_ptr<Foo>'), [])
cls = mod.add_class('ClassThatTakesFoo', allow_subclassing=True)
cls.add_constructor([Parameter.new('boost::shared_ptr<Foo>', 'foo')])
cls.add_method('get_foo', ReturnValue.new('boost::shared_ptr<Foo>'), [])
cls.add_method('get_modified_foo', retval('boost::shared_ptr<Foo>'),
[param('boost::shared_ptr<Foo>', 'foo')],
is_virtual=True, is_const=True)
#### --- error handler ---
class MyErrorHandler(pybindgen.settings.ErrorHandler):
def __init__(self):
super(MyErrorHandler, self).__init__()
self.num_errors = 0
def handle_error(self, wrapper, exception, traceback_):
print("exception %s in wrapper %s" % (exception, wrapper), file=sys.stderr)
self.num_errors += 1
if 0: # verbose?
import traceback
traceback.print_tb(traceback_)
return True
pybindgen.settings.error_handler = MyErrorHandler()
## ---- finally, generate the whole thing ----
mod.generate(FileCodeSink(out_file))
def generate(fp):
mod = Module('foo')
mod.add_include('"ownership.hpp"')
Foo = mod.add_class('Foo', automatic_type_narrowing=True)
Foo.add_constructor([Parameter.new('std::string', 'datum')])
Foo.add_constructor([])
Foo.add_constructor([Parameter.new('const Foo&', 'foo')])
## Zbr is a reference counted class
Zbr = mod.add_class('Zbr',
memory_policy=cppclass.ReferenceCountingMethodsPolicy(
incref_method='Ref',
decref_method='Unref',
peekref_method="GetReferenceCount"))
# allow_subclassing=True)
Zbr.add_constructor([])
Zbr.add_constructor([Parameter.new('std::string', 'datum')])
Zbr.add_method('get_datum', ReturnValue.new('std::string'), [])
Zbr.add_method('get_int',
ReturnValue.new('int'), [Parameter.new('int', 'x')],
is_virtual=True)
Zbr.add_static_attribute('instance_count', ReturnValue.new('int'))
Zbr.add_method(
'get_value', ReturnValue.new('int'),
[Parameter.new('int*', 'x', direction=Parameter.DIRECTION_OUT)])
mod.add_function('store_zbr', None,
[Parameter.new('Zbr*', 'zbr', transfer_ownership=True)])
mod.add_function('invoke_zbr', ReturnValue.new('int'),
[Parameter.new('int', 'x')])
mod.add_function('delete_stored_zbr', None, [])
SomeObject = mod.add_class('SomeObject', allow_subclassing=True)
SomeObject.add_method(
'set_foo_ptr', ReturnValue.new('void'),
[Parameter.new('Foo*', 'foo', transfer_ownership=True)])
SomeObject.add_method(
'set_foo_shared_ptr', ReturnValue.new('void'),
[Parameter.new('Foo*', 'foo', transfer_ownership=False)])
SomeObject.add_method(
'get_foo_shared_ptr',
ReturnValue.new('const Foo*', caller_owns_return=False), [])
SomeObject.add_method('get_foo_ptr',
ReturnValue.new('Foo*', caller_owns_return=True), [])
mod.generate(fp)
def my_module_gen(out_file):
mod = Module('a')
mod.add_include('"a.h"')
mod.add_function('ADoA', None, [])
mod.add_function('ADoB', None, [Parameter.new('uint32_t', 'b')])
mod.add_function('ADoC', ReturnValue.new('uint32_t'), [])
mod.generate(FileCodeSink(out_file) )
def my_module_gen():
module = Module(NAME)
module.add_include('"%s"' % SRC)
A = module.add_class('A', allow_subclassing=True)
A.add_constructor([])
A.add_method('virtualMethod1', None, [], is_virtual=True, is_pure_virtual=True)
A.add_method('virtualMethod2', None, [], is_virtual=True)
B = module.add_class('B', parent=A)
B.add_constructor([])
B.add_constructor([Parameter.new('int', 'a'), Parameter.new('int', 'b')])
B.add_method('virtualMethod1', None, [], is_virtual=True)
B.add_method('overloadedMethod', None, [])
B.add_method('overloadedMethod', None, [Parameter.new('int', 'a'), Parameter.new('int', 'b')])
B.add_method('overloadedMethod', None, [Parameter.new('double', 'd')])
B.add_method('defaultArgs', None, [Parameter.new('int', 'a', default_value='0'),
Parameter.new('int', 'b', default_value='123')])
#bool operator==(const B& other) { return false; }
#bool operator!=(const B& other) { return true; }
#B& operator+(const B& other) { return *this; }
#// anything special done for these?
#int __len__() { return 0; } // yes, added to sequence methods structure
#int __int__() { return 0; } // no but the method is still there
#operator bool() { return true; } // no
#static void staticMethod() {}
#int m_publicAttribute;
C = module.add_class('C', parent=B)
B.add_constructor([])
B.add_constructor([Parameter.new('int', 'a'), Parameter.new('int', 'b')])
B.add_method('returnBaseClassPtr', ReturnValue.new('A*',
#caller_owns_return=True
reference_existing_object=True
), [])
#A* returnBaseClassPtr() { return this; }
#void baseClassParameterPtr(const A* ptr) {}
#void baseClassParameterRef(const A& ptr) {}
output = open(DEST, 'w')
module.generate(FileCodeSink(output))
def my_module_gen(out_file):
mod = Module('e')
mod.add_include('"e.h"')
E = mod.add_class('E',
memory_policy=cppclass.ReferenceCountingMethodsPolicy(
decref_method='Unref', incref_method='Ref'))
if 1:
E.add_function_as_constructor(
"E::CreateWithRef", ReturnValue.new("E*", caller_owns_return=True),
[])
else:
## alternative:
E.add_function_as_constructor(
"E::CreateWithoutRef",
ReturnValue.new("E*", caller_owns_return=False), [])
E.add_method("Do", None, [])
mod.generate(FileCodeSink(out_file))
def register_Tr_piece_methods(root_module, cls):
cls.add_instance_attribute('timeChecked',
'time_t',
is_const=True,
custom_name='time_checked')
cls.add_instance_attribute('hash',
ReturnValue.new('uint8_t *',
array_length=SHA_DIGEST_LENGTH),
is_const=True)
cls.add_instance_attribute('priority', 'int8_t', is_const=True)
cls.add_instance_attribute('dnd',
'bool',
is_const=True,
custom_name='do_not_download')
return
def register_Tr_benc_real_methods(root_module, cls):
root_module.header.writeln("tr_benc *_wrap_tr_bencNewReal(double value);")
root_module.body.writeln("""
tr_benc *_wrap_tr_bencNewReal(double value)
{
tr_benc *benc = tr_new0(tr_benc, 1);
tr_bencInitReal(benc, value);
return benc;
}
""")
cls.add_function_as_constructor("_wrap_tr_bencNewReal",
ReturnValue.new("tr_benc*", caller_owns_return=True),
[param('double', 'value')])
return
def my_module_gen(out_file):
mod = Module('c')
mod.add_include('"c.h"')
C = mod.add_class('C')
C.add_constructor([])
C.add_constructor([Parameter.new('uint32_t', 'c')])
C.add_method('DoA', None, [], is_static=True)
C.add_method('DoB', None, [])
C.add_method('DoC', None, [Parameter.new('uint32_t', 'c')])
C.add_method('DoD', ReturnValue.new('uint32_t'), [])
C.add_method('DoE', None, [], is_virtual=True)
mod.generate(FileCodeSink(out_file) )
def register_Tr_benc_string_methods(root_module, cls):
root_module.header.writeln("tr_benc *_wrap_tr_bencNewStr(const void *str, int str_len);")
root_module.body.writeln("""
tr_benc *_wrap_tr_bencNewStr(const void *str, int str_len)
{
tr_benc *benc = tr_new0(tr_benc, 1);
tr_bencInitStr(benc, str, str_len);
return benc;
}
""")
cls.add_function_as_constructor("_wrap_tr_bencNewStr",
ReturnValue.new("tr_benc*", caller_owns_return=True),
[CharPtrLenParam('const char *', 'value')])
return
def my_module_gen(out_file):
mod = Module('c')
mod.add_include('"c.h"')
C = mod.add_class('C')
C.add_constructor([])
C.add_constructor([Parameter.new('uint32_t', 'c')])
C.add_method('DoA', None, [], is_static=True)
C.add_method('DoB', None, [])
C.add_method('DoC', None, [Parameter.new('uint32_t', 'c')])
C.add_method('DoD', ReturnValue.new('uint32_t'), [])
C.add_method('DoE', None, [], is_virtual=True)
mod.generate(FileCodeSink(out_file))
def generate_callback_classes(out, callbacks):
for callback_impl_num, template_parameters in enumerate(callbacks):
sink = MemoryCodeSink()
cls_name = "ns3::Callback< %s >" % ', '.join(template_parameters)
class_name = "PythonCallbackImpl%i" % callback_impl_num
sink.writeln( % (class_name, ', '.join(template_parameters), class_name, class_name, class_name, class_name))
sink.indent()
callback_return = template_parameters[0]
return_ctype = ctypeparser.parse_type(callback_return)
if ('const' in return_ctype.remove_modifiers()):
kwargs = {'is_const': True}
else:
kwargs = {}
try:
return_type = ReturnValue.new(str(return_ctype), **kwargs)
except (typehandlers.TypeLookupError, typehandlers.TypeConfigurationError), ex:
warnings.warn("***** Unable to register callback; Return value '%s' error (used in %s): %r"
% (callback_return, cls_name, ex),
Warning)
continue
arguments = []
ok = True
callback_parameters = [arg for arg in template_parameters[1:] if arg != 'ns3::empty']
for arg_num, arg_type in enumerate(callback_parameters):
arg_name = 'arg%i' % (arg_num+1)
param_ctype = ctypeparser.parse_type(arg_type)
if ('const' in param_ctype.remove_modifiers()):
kwargs = {'is_const': True}
else:
kwargs = {}
try:
arguments.append(Parameter.new(str(param_ctype), arg_name, **kwargs))
except (typehandlers.TypeLookupError, typehandlers.TypeConfigurationError), ex:
warnings.warn("***** Unable to register callback; parameter '%s %s' error (used in %s): %r"
% (arg_type, arg_name, cls_name, ex),
Warning)
ok = False
def generate_callback_classes(out, callbacks):
for callback_impl_num, template_parameters in enumerate(callbacks):
sink = MemoryCodeSink()
cls_name = "ns3::Callback< %s >" % ', '.join(template_parameters)
#print >> sys.stderr, "***** trying to register callback: %r" % cls_name
class_name = "PythonCallbackImpl%i" % callback_impl_num
sink.writeln('''
class %s : public ns3::CallbackImpl<%s>
{
public:
PyObject *m_callback;
%s(PyObject *callback)
{
Py_INCREF(callback);
m_callback = callback;
}
virtual ~%s()
{
Py_DECREF(m_callback);
m_callback = NULL;
}
virtual bool IsEqual(ns3::Ptr<const ns3::CallbackImplBase> other_base) const
{
const %s *other = dynamic_cast<const %s*> (ns3::PeekPointer (other_base));
if (other != NULL)
return (other->m_callback == m_callback);
else
return false;
}
''' % (class_name, ', '.join(template_parameters), class_name, class_name,
class_name, class_name))
sink.indent()
callback_return = template_parameters[0]
return_ctype = ctypeparser.parse_type(callback_return)
if ('const' in return_ctype.remove_modifiers()):
kwargs = {'is_const': True}
else:
kwargs = {}
try:
return_type = ReturnValue.new(str(return_ctype), **kwargs)
except (typehandlers.TypeLookupError,
typehandlers.TypeConfigurationError), ex:
warnings.warn(
"***** Unable to register callback; Return value '%s' error (used in %s): %r"
% (callback_return, cls_name, ex), Warning)
continue
arguments = []
ok = True
callback_parameters = [
arg for arg in template_parameters[1:] if arg != 'ns3::empty'
]
for arg_num, arg_type in enumerate(callback_parameters):
arg_name = 'arg%i' % (arg_num + 1)
param_ctype = ctypeparser.parse_type(arg_type)
if ('const' in param_ctype.remove_modifiers()):
kwargs = {'is_const': True}
else:
kwargs = {}
try:
arguments.append(
Parameter.new(str(param_ctype), arg_name, **kwargs))
except (typehandlers.TypeLookupError,
typehandlers.TypeConfigurationError), ex:
warnings.warn(
"***** Unable to register callback; parameter '%s %s' error (used in %s): %r"
% (arg_type, arg_name, cls_name, ex), Warning)
ok = False
def register_Tr_benc_list_methods(root_module, cls):
root_module.header.writeln("tr_benc *_wrap_tr_bencNewList(size_t reserveCount);")
root_module.body.writeln("""
tr_benc *_wrap_tr_bencNewList(size_t reserveCount)
{
tr_benc *benc = tr_new0(tr_benc, 1);
tr_bencInitList(benc, reserveCount);
return benc;
}
""")
cls.add_function_as_constructor("_wrap_tr_bencNewList",
ReturnValue.new("tr_benc*", caller_owns_return=True),
[param('size_t', 'reserve_count')])
cls.add_function_as_method('tr_bencListAddBool',
ReturnValue.new('tr_benc *', caller_owns_return=False),
[param('BencList *', 'benc', transfer_ownership=False),
param('bool', 'value')],
custom_name='add_bool')
cls.add_function_as_method('tr_bencListAddInt',
ReturnValue.new('tr_benc *', caller_owns_return=False),
[param('BencList *', 'benc', transfer_ownership=False),
param('int64_t', 'value')],
custom_name='add_int')
cls.add_function_as_method('tr_bencListAddReal',
ReturnValue.new('tr_benc *', caller_owns_return=False),
[param('BencList *', 'benc', transfer_ownership=False),
param('double', 'value')],
custom_name='add_real')
cls.add_function_as_method('tr_bencListAddStr',
ReturnValue.new('tr_benc *', caller_owns_return=False),
[param('BencList *', 'benc', transfer_ownership=False),
param('char const *', 'value')],
custom_name='add_string')
cls.add_function_as_method('tr_bencListAddDict',
ReturnValue.new('tr_benc *', caller_owns_return=False),
[param('BencList *', 'benc', transfer_ownership=False),
param('size_t', 'reserve')],
custom_name='add_dict')
cls.add_function_as_method('tr_bencListAddList',
'tr_benc *',
[param('BencList *', 'benc', transfer_ownership=False),
param('size_t', 'reserve')],
custom_name='add_list')
cls.add_function_as_method('tr_bencListSize',
'size_t',
[param('BencList *', 'benc', transfer_ownership=False)],
custom_name='__len__')
cls.add_function_as_method('tr_bencListChild',
BencValueReturn('tr_benc *', index='index'),
[param('BencList *', 'benc', transfer_ownership=False),
param('int', 'index')],
custom_name='__getitem__')
cls.add_custom_method_wrapper('__setitem__',
'_wrap_transmission_tr_bencListSet',
flags=["METH_VARARGS", "METH_KEYWORDS"],
wrapper_body="""
PyObject *
_wrap_transmission_tr_bencListSet(PyBencList *self, PyObject *args,
PyObject *kwargs, PyObject **return_exception)
{
PyObject *py_value = NULL;
PyObject *exc_type, *traceback;
tr_benc *retval;
int index;
const char *keywords[] = {"index", "value", NULL};
if (!PyArg_ParseTupleAndKeywords(args, kwargs, (char *) "iO", (char **) keywords, &index, &py_value)) {
PyErr_Fetch(&exc_type, return_exception, &traceback);
Py_XDECREF(exc_type);
Py_XDECREF(traceback);
return NULL;
}
retval = tr_bencListChild(self->obj, index);
if (!retval) {
PyErr_SetString(PyExc_NotImplementedError,
"adding new items through sequence methods currently not supported");
return NULL;
}
if (tr_bencIsBool(retval) && PyBool_Check(py_value)) {
tr_bencInitBool(retval, (py_value == Py_True));
Py_RETURN_NONE;
}
else if (tr_bencIsInt(retval) && PyLong_Check(py_value)) {
tr_bencInitReal(retval, PyLong_AsLong(py_value));
Py_RETURN_NONE;
}
else if (tr_bencIsReal(retval) && PyFloat_Check(py_value)) {
tr_bencInitReal(retval, PyFloat_AsDouble(py_value));
Py_RETURN_NONE;
}
else if (tr_bencIsString(retval) && PyUnicode_Check(py_value)) {
tr_bencFree(retval);
tr_bencInitStr(retval, PyUnicode_AsUTF8(py_value), -1);
Py_RETURN_NONE;
}
else if (tr_bencIsDict(retval) || tr_bencIsList(retval)) {
PyErr_SetString(PyExc_NotImplementedError,
"assigning to BencList and BencDict types currently not supported");
return NULL;
}
PyErr_Format(PyExc_ValueError, "Unable to set index '%i'", index);
return NULL;
}"""
)
return
def generate_callback_classes(module, callbacks):
out = module.after_forward_declarations
for callback_impl_num, template_parameters in enumerate(callbacks):
sink = MemoryCodeSink()
cls_name = "ns3::Callback< %s >" % ', '.join(template_parameters)
#print >> sys.stderr, "***** trying to register callback: %r" % cls_name
class_name = "PythonCallbackImpl%i" % callback_impl_num
sink.writeln('''
class %s : public ns3::CallbackImpl<%s>
{
public:
PyObject *m_callback;
%s(PyObject *callback)
{
Py_INCREF(callback);
m_callback = callback;
}
virtual ~%s()
{
PyGILState_STATE __py_gil_state;
__py_gil_state = (PyEval_ThreadsInitialized() ? PyGILState_Ensure() : (PyGILState_STATE) 0);
Py_DECREF(m_callback);
m_callback = NULL;
PyGILState_Release(__py_gil_state);
}
virtual bool IsEqual(ns3::Ptr<const ns3::CallbackImplBase> other_base) const
{
const %s *other = dynamic_cast<const %s*> (ns3::PeekPointer (other_base));
if (other != NULL)
return (other->m_callback == m_callback);
else
return false;
}
''' % (class_name, ', '.join(template_parameters), class_name, class_name, class_name, class_name))
sink.indent()
callback_return = template_parameters[0]
return_ctype = ctypeparser.parse_type(callback_return)
if ('const' in return_ctype.remove_modifiers()):
kwargs = {'is_const': True}
else:
kwargs = {}
try:
return_type = ReturnValue.new(str(return_ctype), **kwargs)
except (typehandlers.TypeLookupError, typehandlers.TypeConfigurationError) as ex:
warnings.warn("***** Unable to register callback; Return value '%s' error (used in %s): %r"
% (callback_return, cls_name, ex),
Warning)
continue
arguments = []
ok = True
callback_parameters = [arg for arg in template_parameters[1:] if arg != 'ns3::empty']
for arg_num, arg_type in enumerate(callback_parameters):
arg_name = 'arg%i' % (arg_num+1)
param_ctype = ctypeparser.parse_type(arg_type)
if ('const' in param_ctype.remove_modifiers()):
kwargs = {'is_const': True}
else:
kwargs = {}
try:
param = Parameter.new(str(param_ctype), arg_name, **kwargs)
cpp_class = getattr(param, "cpp_class", None)
if isinstance(cpp_class, cppclass.CppClass):
# check if the "helper class" can be constructed
if cpp_class.helper_class is not None:
cpp_class.helper_class.generate_forward_declarations(
MemoryCodeSink())
if cpp_class.helper_class.cannot_be_constructed:
cpp_class.helper_class = None
cpp_class.helper_class_disabled = True
arguments.append(param)
except (typehandlers.TypeLookupError, typehandlers.TypeConfigurationError) as ex:
warnings.warn("***** Unable to register callback; parameter '%s %s' error (used in %s): %r"
% (arg_type, arg_name, cls_name, ex),
Warning)
ok = False
if not ok:
try:
typehandlers.return_type_matcher.lookup(cls_name)[0].DISABLED = True
except typehandlers.TypeLookupError:
pass
try:
typehandlers.param_type_matcher.lookup(cls_name)[0].DISABLED = True
except typehandlers.TypeLookupError:
pass
continue
wrapper = CallbackImplProxyMethod(return_type, arguments)
wrapper.generate(sink, 'operator()', decl_modifiers=[])
sink.unindent()
sink.writeln('};\n')
print("Flushing to ", out, file=sys.stderr)
sink.flush_to(out)
def register_Tr_benc_dict_methods(root_module, cls):
root_module.header.writeln("tr_benc *_wrap_tr_bencNewDict(size_t reserveCount);")
root_module.body.writeln("""
tr_benc *_wrap_tr_bencNewDict(size_t reserveCount)
{
tr_benc *benc = tr_new0(tr_benc, 1);
tr_bencInitDict(benc, reserveCount);
return benc;
}
""")
cls.add_function_as_constructor("_wrap_tr_bencNewDict",
ReturnValue.new("tr_benc*", caller_owns_return=True),
[param('size_t', 'reserve_count')])
cls.add_function_as_method('tr_bencDictAddBool',
ReturnValue.new('tr_benc *', caller_owns_return=False),
[param('BencDict *', 'benc', transfer_ownership=False),
param('char const *', 'key'),
param('bool', 'value')],
custom_name='add_bool')
cls.add_function_as_method('tr_bencDictAddBool',
ReturnValue.new('tr_benc *', caller_owns_return=False),
[param('BencDict *', 'benc', transfer_ownership=False),
param('char const *', 'key'),
param('bool', 'value')],
custom_name='add_bool')
cls.add_function_as_method('tr_bencDictAddInt',
ReturnValue.new('tr_benc *', caller_owns_return=False),
[param('BencDict *', 'benc', transfer_ownership=False),
param('char const *', 'key'),
param('int64_t', 'value')],
custom_name='add_int')
cls.add_function_as_method('tr_bencDictAddReal',
ReturnValue.new('tr_benc *', caller_owns_return=False),
[param('BencDict *', 'benc', transfer_ownership=False),
param('char const *', 'key'),
param('double', 'value')],
custom_name='add_real')
cls.add_function_as_method('tr_bencDictAddStr',
ReturnValue.new('tr_benc *', caller_owns_return=False),
[param('BencDict *', 'benc', transfer_ownership=False),
param('char const *', 'key'),
param('char const *', 'value')],
custom_name='add_string')
cls.add_function_as_method('tr_bencDictAddDict',
ReturnValue.new('tr_benc *', caller_owns_return=False),
[param('BencDict *', 'benc', transfer_ownership=False),
param('char const *', 'key'),
param('size_t', 'reserve')],
custom_name='add_dict')
cls.add_function_as_method('tr_bencDictAddList',
'tr_benc *',
[param('BencDict *', 'benc', transfer_ownership=False),
param('char const *', 'key'),
param('size_t', 'reserve')],
custom_name='add_list')
cls.add_function_as_method('tr_bencLoadFile',
'int',
[param('BencDict *', 'benc', transfer_ownership=False),
param('tr_fmt_mode', 'mode'),
param('char const *', 'filename')],
custom_name='load_file')
cls.add_function_as_method('tr_bencToFile',
'int',
[param('BencDict *', 'benc', transfer_ownership=False),
param('tr_fmt_mode', 'mode'),
param('char const *', 'filename')],
custom_name='to_file')
root_module.header.writeln("#define _wrap_BencDict_contains(benc, key) (tr_bencDictFind(benc, key) != NULL)")
cls.add_function_as_method('_wrap_BencDict_contains',
'bool',
[param('BencDict *', 'benc', transfer_ownership=False),
param('char const *', 'key')],
custom_name='__contains__')
cls.add_custom_method_wrapper('keys',
'_wrap_transmission_tr_benc_keys',
flags=["METH_NOARGS"],
wrapper_body="""
PyObject *
_wrap_transmission_tr_benc_keys(PyBencDict *self, PyObject **return_exception)
{
int idx;
int length = tr_bencDictSize(self->obj);
PyObject *py_list = PyList_New(length);
for(idx = 0; idx < length; ++idx) {
const char * key;
tr_benc * val;
if(tr_bencDictChild(self->obj, idx, &key, &val)) {
PyList_SetItem(py_list, idx, Py_BuildValue((char*)"s", key));
}
}
return py_list;
}""")
cls.add_function_as_method('tr_bencDictFind',
'tr_benc *',
[param('BencDict *', 'benc', transfer_ownership=False),
param('char const *', 'key')],
custom_name='get')
## mapping methods
cls.add_function_as_method('tr_bencDictSize',
'size_t',
[param('BencDict *', 'benc', transfer_ownership=False)],
custom_name='__maplen__')
root_module.header.writeln("tr_benc *_wrap_tr_bencDictChild(tr_benc * benc, int i);")
root_module.body.writeln("tr_benc *_wrap_tr_bencDictChild(tr_benc * benc, int i)\n"
"{\n"
" const char *key;\n"
" tr_benc *val;\n"
" if (tr_bencDictChild(benc, i, &key, &val))\n"
" return val;\n"
" return NULL;\n"
"}")
cls.add_function_as_method('_wrap_tr_bencDictChild',
BencValueReturn('tr_benc *', index='index'),
[param('BencDict *', 'benc', transfer_ownership=False),
param('int', 'index')],
custom_name='__mapget__')
cls.add_function_as_method('tr_bencDictFind',
BencValueReturn('tr_benc *', key='key'),
[param('BencDict *', 'benc', transfer_ownership=False),
param('char const *', 'key')],
custom_name='__mapget__')
cls.add_custom_method_wrapper('__mapset__',
'_wrap_transmission_tr_bencDictSet',
flags=["METH_VARARGS", "METH_KEYWORDS"],
wrapper_body="""
PyObject *
_wrap_transmission_tr_bencDictSet(PyBencDict *self, PyObject *args,
PyObject *kwargs, PyObject **return_exception)
{
PyObject *py_value = NULL;
PyObject *exc_type, *traceback;
tr_benc *retval;
char const *key;
int index;
const char *keywords[] = {"key", "value", NULL};
if (PyArg_ParseTupleAndKeywords(args, kwargs, (char *) "iO", (char **) keywords, &index, &py_value)) {
if (!tr_bencDictChild(self->obj, index, &key, &retval)) {
PyErr_SetString(PyExc_NotImplementedError,
"adding new items through mapping methods currently not supported");
return NULL;
}
}
else if (!PyArg_ParseTupleAndKeywords(args, kwargs, (char *) "sO", (char **) keywords, &key, &py_value)) {
PyErr_Fetch(&exc_type, return_exception, &traceback);
Py_XDECREF(exc_type);
Py_XDECREF(traceback);
return NULL;
}
/*
if (!retval && !tr_bencDictFind(self->obj, key)) {
PyErr_SetString(PyExc_NotImplementedError,
"adding new items through mapping methods currently not supported");
return NULL;
}
*/
if (PyBool_Check(py_value)) {
if (tr_bencDictAddBool(self->obj, key, (py_value == Py_True)))
Py_RETURN_NONE;
}
else if (PyLong_Check(py_value)) {
if (tr_bencDictAddInt(self->obj, key, PyLong_AsLong(py_value)))
Py_RETURN_NONE;
}
else if (PyFloat_Check(py_value)) {
if (tr_bencDictAddReal(self->obj, key, PyFloat_AsDouble(py_value)))
Py_RETURN_NONE;
}
else if (PyUnicode_Check(py_value)) {
if (tr_bencDictAddStr(self->obj, key, PyUnicode_AsUTF8(py_value)))
Py_RETURN_NONE;
}
else if (PyObject_IsInstance(py_value, (PyObject *)&PyBencDict_Type) ||
PyObject_IsInstance(py_value, (PyObject *)&PyBencList_Type)) {
PyErr_SetString(PyExc_NotImplementedError,
"assigning BencList and BencDict types currently not supported");
return NULL;
}
PyErr_Format(PyExc_ValueError, "Unable to set '%s'", key);
return NULL;
}"""
)
return
def register_Tr_ctor_methods(root_module, cls):
cls.add_function_as_constructor("tr_ctorNew",
ReturnValue.new("tr_ctor*", caller_owns_return=True),
[param('tr_session const *', 'session', null_ok=True)])
cls.add_instance_attribute('bandwidth_priority', 'tr_priority_t', #XXX: check for value in tr.priority
is_pure_c=True,
getter='tr_ctorGetBandwidthPriority',
setter='tr_ctorSetBandwidthPriority')
root_module.header.writeln("bool _wrap_tr_ctorGetDeleteSource(const tr_ctor * ctor);")
root_module.body.writeln("bool _wrap_tr_ctorGetDeleteSource(const tr_ctor * ctor)\n"
"{\n"
" bool setme = 0;\n"
" tr_ctorGetDeleteSource(ctor, &setme);\n"
" return setme;\n"
"}")
cls.add_instance_attribute('delete_source', 'bool',
is_pure_c=True,
getter='_wrap_tr_ctorGetDeleteSource',
setter='tr_ctorSetDeleteSource')
cls.add_instance_attribute('session',
ReturnValue.new("tr_session *", reference_existing_object=True),
is_const=True,
is_pure_c=True,
getter='tr_ctorGetSession')
cls.add_instance_attribute('source_file', 'char const *',
is_const=True,
is_pure_c=True,
getter='tr_ctorGetSourceFile')
root_module.header.writeln("uint16_t _wrap_tr_ctorGetPeerLimit(const tr_ctor * ctor, tr_ctorMode mode);")
root_module.body.writeln("uint16_t _wrap_tr_ctorGetPeerLimit(const tr_ctor * ctor, tr_ctorMode mode)\n"
"{\n"
" uint16_t count = 0;\n"
" if (tr_ctorGetPeerLimit(ctor, mode, &count))\n"
" return count;\n"
" else if (tr_ctorGetPeerLimit(ctor, TR_FALLBACK, &count)) \n"
" return count;\n"
" return 0;\n"
"}")
cls.add_instance_attribute('peer_limit', 'uint16_t',
is_pure_c=True,
getter='_wrap_tr_ctorGetPeerLimit',
setter='tr_ctorSetPeerLimit',
closure='&tr_force', closure_cast='*(tr_ctorMode*)')
root_module.header.writeln("const char *_wrap_tr_ctorGetDownloadDir(const tr_ctor * ctor, tr_ctorMode mode);")
root_module.body.writeln("const char *_wrap_tr_ctorGetDownloadDir(const tr_ctor * ctor, tr_ctorMode mode)\n"
"{\n"
" const char *dir;\n"
" if (tr_ctorGetDownloadDir(ctor, mode, &dir) == 0)\n"
" return dir;\n"
" else if (tr_ctorGetDownloadDir(ctor, TR_FALLBACK, &dir) == 0)\n"
" return dir;\n"
" return NULL;\n"
"}")
cls.add_instance_attribute('download_directory', 'char const *',
is_pure_c=True,
getter='_wrap_tr_ctorGetDownloadDir',
setter='tr_ctorSetDownloadDir',
closure='&tr_force', closure_cast='*(tr_ctorMode*)')
root_module.header.writeln("uint16_t _wrap_tr_ctorGetPaused(const tr_ctor * ctor, tr_ctorMode mode);")
root_module.body.writeln("uint16_t _wrap_tr_ctorGetPaused(const tr_ctor * ctor, tr_ctorMode mode)\n"
"{\n"
" bool paused = 0;\n"
" if (tr_ctorGetPaused(ctor, mode, &paused) == 0)\n"
" return paused;\n"
" tr_ctorGetPaused(ctor, TR_FALLBACK, &paused); \n"
" return paused;\n"
"}")
cls.add_instance_attribute('paused', 'bool',
is_pure_c=True,
getter='_wrap_tr_ctorGetPaused',
setter='tr_ctorSetPaused',
closure='&tr_force', closure_cast='*(tr_ctorMode*)')
cls.add_function_as_method('tr_ctorGetMetainfo',
'void',
[param('tr_ctor *', 'ctor', transfer_ownership=False),
BencOutParam('const tr_benc **', 'dict', merge_dict=True)],
custom_name='metainfo')
cls.add_function_as_method('tr_torrentParse',
'tr_parse_result',
[param('tr_ctor *', 'ctor', transfer_ownership=False),
param('NULL', 'info')],
custom_name='parse')
cls.add_function_as_method('tr_ctorSetMetainfoFromMagnetLink',
'int',
[param('tr_ctor *', 'ctor', transfer_ownership=False),
param('char const *', 'magnet')],
custom_name='set_metainfo_from_magnet')
cls.add_function_as_method('tr_ctorSetMetainfoFromFile',
'int',
[param('tr_ctor *', 'ctor', transfer_ownership=False),
param('char const *', 'filename')],
custom_name='set_metainfo_from_file')
cls.add_function_as_method('tr_ctorSetMetainfoFromHash',
'int',
[param('tr_ctor *', 'ctor', transfer_ownership=False),
param('char const *', 'hash_tag')],
custom_name='set_metainfo_from_hash')
return
def generate_callback_classes(module, callbacks):
out = module.after_forward_declarations
for callback_impl_num, template_parameters in enumerate(callbacks):
sink = MemoryCodeSink()
cls_name = "ns3::Callback< %s >" % ', '.join(template_parameters)
#print >> sys.stderr, "***** trying to register callback: %r" % cls_name
class_name = "PythonCallbackImpl%i" % callback_impl_num
sink.writeln('''
class %s : public ns3::CallbackImpl<%s>
{
public:
PyObject *m_callback;
%s(PyObject *callback)
{
Py_INCREF(callback);
m_callback = callback;
}
virtual ~%s()
{
PyGILState_STATE __py_gil_state;
__py_gil_state = (PyEval_ThreadsInitialized() ? PyGILState_Ensure() : (PyGILState_STATE) 0);
Py_DECREF(m_callback);
m_callback = NULL;
PyGILState_Release(__py_gil_state);
}
virtual bool IsEqual(ns3::Ptr<const ns3::CallbackImplBase> other_base) const
{
const %s *other = dynamic_cast<const %s*> (ns3::PeekPointer (other_base));
if (other != NULL)
return (other->m_callback == m_callback);
else
return false;
}
''' % (class_name, ', '.join(template_parameters), class_name, class_name,
class_name, class_name))
sink.indent()
callback_return = template_parameters[0]
return_ctype = ctypeparser.parse_type(callback_return)
if ('const' in return_ctype.remove_modifiers()):
kwargs = {'is_const': True}
else:
kwargs = {}
try:
return_type = ReturnValue.new(str(return_ctype), **kwargs)
except (typehandlers.TypeLookupError,
typehandlers.TypeConfigurationError) as ex:
warnings.warn(
"***** Unable to register callback; Return value '%s' error (used in %s): %r"
% (callback_return, cls_name, ex), Warning)
continue
arguments = []
ok = True
callback_parameters = [
arg for arg in template_parameters[1:] if arg != 'ns3::empty'
]
for arg_num, arg_type in enumerate(callback_parameters):
arg_name = 'arg%i' % (arg_num + 1)
param_ctype = ctypeparser.parse_type(arg_type)
if ('const' in param_ctype.remove_modifiers()):
kwargs = {'is_const': True}
else:
kwargs = {}
try:
param = Parameter.new(str(param_ctype), arg_name, **kwargs)
cpp_class = getattr(param, "cpp_class", None)
if isinstance(cpp_class, cppclass.CppClass):
# check if the "helper class" can be constructed
if cpp_class.helper_class is not None:
cpp_class.helper_class.generate_forward_declarations(
MemoryCodeSink())
if cpp_class.helper_class.cannot_be_constructed:
cpp_class.helper_class = None
cpp_class.helper_class_disabled = True
arguments.append(param)
except (typehandlers.TypeLookupError,
typehandlers.TypeConfigurationError) as ex:
warnings.warn(
"***** Unable to register callback; parameter '%s %s' error (used in %s): %r"
% (arg_type, arg_name, cls_name, ex), Warning)
ok = False
if not ok:
try:
typehandlers.return_type_matcher.lookup(
cls_name)[0].DISABLED = True
except typehandlers.TypeLookupError:
pass
try:
typehandlers.param_type_matcher.lookup(
cls_name)[0].DISABLED = True
except typehandlers.TypeLookupError:
pass
continue
wrapper = CallbackImplProxyMethod(return_type, arguments)
wrapper.generate(sink, 'operator()', decl_modifiers=[])
sink.unindent()
sink.writeln('};\n')
print("Flushing to ", out, file=sys.stderr)
sink.flush_to(out)
def customize_module(module):
pybindgen.settings.wrapper_registry = pybindgen.settings.StdMapWrapperRegistry
wrapper_body = '''
static PyObject *
_wrap_foofunction_that_takes_foo_from_string(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args,
PyObject *kwargs, PyObject **return_exception)
{
PyObject *py_retval;
char *datum;
const char *keywords[] = {"foo", NULL};
if (!PyArg_ParseTupleAndKeywords(args, kwargs, (char *) "s", (char **) keywords, &datum)) {
{
PyObject *exc_type, *traceback;
PyErr_Fetch(&exc_type, return_exception, &traceback);
Py_XDECREF(exc_type);
Py_XDECREF(traceback);
}
return NULL;
}
function_that_takes_foo(Foo(datum));
Py_INCREF(Py_None);
py_retval = Py_None;
return py_retval;
}
'''
if len(module.classes) == 0:
# Some tests, eg. foomodulegen4.py, don't have Bar and Foo classes
# defined.
return
module.add_custom_function_wrapper(
'function_that_takes_foo',
'_wrap_foofunction_that_takes_foo_from_string',
wrapper_body,
docstring="I'm awake you rascals!")
## test a custom method wrapper
Bar, = [cls for cls in module.classes if cls.name == 'Bar']
wrapper_body = '''
static PyObject *
_wrap_PyBar_Hooray_lenx(PyBar *PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs,
PyObject **return_exception)
{
PyObject *py_retval;
int x;
const char *keywords[] = {"x", NULL};
if (!PyArg_ParseTupleAndKeywords(args, kwargs, (char *) "i", (char **) keywords, &x)) {
PyObject *exc_type, *traceback;
PyErr_Fetch(&exc_type, return_exception, &traceback);
Py_XDECREF(exc_type);
Py_XDECREF(traceback);
return NULL;
}
std::string retval;
retval = Bar::Hooray();
py_retval = Py_BuildValue((char *) "i", int(retval.size() + x));
return py_retval;
}
'''
Bar.add_custom_method_wrapper(
"Hooray",
"_wrap_PyBar_Hooray_lenx",
wrapper_body,
flags=["METH_VARARGS", "METH_KEYWORDS", "METH_STATIC"],
docstring='Zzzz.... Have good dreams.')
Foo, = [cls for cls in module.classes if cls.name == 'Foo']
def Foo_instance_creation_function(dummy_cpp_class, code_block, lvalue,
parameters, construct_type_name):
code_block.write_code("%s = new %s(%s);" %
(lvalue, construct_type_name, parameters))
code_block.write_code("%s->initialize();" % (lvalue, ))
Foo.set_instance_creation_function(Foo_instance_creation_function)
VectorLike2, = [cls for cls in module.classes if cls.name == 'VectorLike2']
VectorLike2.add_container_traits(ReturnValue.new('double'),
begin_method='Begin',
end_method='End',
iterator_type='Iterator')
MapLike, = [cls for cls in module.classes if cls.name == 'MapLike']
MapLike.add_container_traits(
(ReturnValue.new('int'), ReturnValue.new('double')),
begin_method='Begin',
end_method='End',
iterator_type='Iterator',
is_mapping=True)
def register_functions(root_module):
module = root_module
module.add_function(
"tr_sessionLoadSettings",
typedefs.ErrorCheckReturn(
"bool",
exception="PyExc_ValueError",
error_string='"unable to load settings"',
error_cleanup="Py_DECREF(py_dictionary);\n",
),
[
typedefs.BencOutParam("BencDict *", "dictionary"),
param("char *", "config_dir", default_value="NULL"),
param("char *", "app_name", default_value='(char*)"Transmission"'),
],
custom_name="user_settings",
docstring="Load settings from the configuration directory's settings.json file "
"using Transmission's default settings as fallbacks for missing keys\\n\\n"
"Args:\\n"
" config_dir (str): configuration directory or None\\n"
" app_name (str): used to find default configuration directory if "
"config_dir is None\\n"
"Returns:\\n"
" (BencDict) user settings",
)
module.add_function(
"tr_sessionGetDefaultSettings",
"void",
[typedefs.BencOutParam("BencDict *", "dictionary")],
custom_name="default_settings",
docstring="Get Transmission's default settings\\n\\n" "Returns:\\n" " (BencDict) default settings",
)
module.add_function(
"tr_getDefaultConfigDir",
"char const *",
[param("char const *", "app_name", default_value='"Transmission"')],
custom_name="default_config_dir",
docstring="Get the default configuration directory\\n\\n"
"Returns:\\n"
" (str) default configuration directory",
)
module.add_function(
"tr_getDefaultDownloadDir",
"char const *",
[],
custom_name="default_download_dir",
docstring="Get the default download directory\\n\\n" "Returns:\\n" " (str) default download directory",
)
module.add_function(
"tr_getMessageQueuing",
"bool",
[],
custom_name="message_queuing_enabled",
docstring="Check if message queuing is enabled\\n\\n" "Returns:\\n" " (bool) queuing is enabled",
)
module.add_function(
"tr_setMessageQueuing",
"void",
[param("bool", "enabled")],
custom_name="message_queuing_set",
docstring="If enabled logging messages will be queued instead of going to stderr\\n\\n"
"Args:\\n"
" enabled (bool): turn on/off message queuing\\n",
)
module.add_function(
"tr_getQueuedMessages",
ReturnValue.new("tr_msg_list *", caller_owns_return=True),
[],
custom_name="queued_messages",
docstring="Retrieve a list of queued messaged\\n\\n" "Returns:\\n" " (list) logged messages",
)
module.add_function(
"tr_torrentsQueueMoveUp",
"void",
[typedefs.ListParam("Torrent", "torrents")],
custom_name="queue_move_up",
docstring="Move Torrents up in download queue\\n\\n" "Args:\\n" " torrents (list): Torrents to move\\n",
)
module.add_function(
"tr_torrentsQueueMoveDown",
"void",
[typedefs.ListParam("Torrent", "torrents")],
custom_name="queue_move_down",
docstring="Move Torrents down in download queue\\n\\n" "Args:\\n" " torrents (list): Torrents to move\\n",
)
module.add_function(
"tr_torrentsQueueMoveTop",
"void",
[typedefs.ListParam("Torrent", "torrents")],
custom_name="queue_move_top",
docstring="Move Torrents to top of download queue\\n\\n" "Args:\\n" " torrents (list): Torrents to move\\n",
)
module.add_function(
"tr_torrentsQueueMoveBottom",
"void",
[typedefs.ListParam("Torrent", "torrents")],
custom_name="queue_move_bottom",
docstring="Move Torrents to bottom of download queue\\n\\n"
"Args:\\n"
" torrents (list): Torrents to move\\n",
)
submodule = SubModule(
"formatter", parent=module, docstring="Utility functions for setting the unit formatting strings for printing"
)
submodule.add_function(
"tr_formatter_mem_init",
"void",
[
param("unsigned int", "kilo", default_value="1000"),
param("const char *", "kb", default_value='"KiB"'),
param("const char *", "mb", default_value='"MiB"'),
param("const char *", "gb", default_value='"GiB"'),
param("const char *", "tb", default_value='"TiB"'),
],
custom_name="memory_units",
docstring="Set the multiplier and formatting strings for memory units\\n\\n"
"Args:\\n"
" kilo (int): Thousands multiplier\\n"
" kb (str): Kilobytes string representation\\n"
" mb (str): Megabytes string representation\\n"
" gb (str): Gigabytes string representation\\n"
" tb (str): Terabytes string representation\\n",
)
submodule.add_function(
"tr_formatter_size_init",
"void",
[
param("unsigned int", "kilo"),
param("const char *", "kb"),
param("const char *", "mb"),
param("const char *", "gb"),
param("const char *", "tb"),
],
custom_name="size_units",
docstring="Set the multiplier and formatting strings for file size units\\n\\n"
"Args:\\n"
" kilo (int): Thousands multiplier\\n"
" kb (str): Kilobytes string representation\\n"
" mb (str): Megabytes string representation\\n"
" gb (str): Gigabytes string representation\\n"
" tb (str): Terabytes string representation\\n",
)
submodule.add_function(
"tr_formatter_speed_init",
"void",
[
param("unsigned int", "kilo"),
param("const char *", "kb"),
param("const char *", "mb"),
param("const char *", "gb"),
param("const char *", "tb"),
],
custom_name="speed_units",
docstring="Set the multiplier and formatting strings for network speed units\\n\\n"
"Args:\\n"
" kilo (int): Thousands multiplier\\n"
" kb (str): Kilobytes string representation\\n"
" mb (str): Megabytes string representation\\n"
" gb (str): Gigabytes string representation\\n"
" tb (str): Terabytes string representation\\n",
)
return
def register_Tr_session_methods(root_module, cls):
cls.docstring = ('Class that manages the Transmission session\\n'
'\\n'
'Args:\\n'
' tag (str): \'gtk\', \'macosx\', \'daemon\', etc...\\n'
' this is only for pre-1.30 resume files\\n'
' config_dir (str): directory for configuration files\\n'
' message_queueing (bool): if True, messages will be queued\\n'
' settings (BencDict): session settings')
con = cls.add_function_as_constructor("tr_sessionInit",
ReturnValue.new("tr_session *", caller_owns_return=True),
[param('const char *', 'tag'),
param('const char *', 'config_dir'),
param('bool', 'message_queueing'),
param('BencDict *', 'settings', transfer_ownership=False)])
root_module.header.writeln("double _wrap_tr_sessionGetActiveSpeedLimit(const tr_session *session,\n"
" tr_direction dir);")
root_module.body.writeln("double _wrap_tr_sessionGetActiveSpeedLimit(const tr_session *session,\n"
" tr_direction dir)\n"
"{\n"
" double speed;\n"
" if (tr_sessionGetActiveSpeedLimit_KBps(session, dir, &speed))\n"
" return speed;\n"
" return -1;\n"
"}")
cls.add_instance_attribute('active_speed_limit_up', 'double',
is_const=True,
is_pure_c=True,
getter='_wrap_tr_sessionGetActiveSpeedLimit',
closure='&tr_up', closure_cast='*(tr_direction*)',
docstring="Get the active upload speed limit")
cls.add_instance_attribute('active_speed_limit_down', 'double',
is_const=True,
is_pure_c=True,
getter='_wrap_tr_sessionGetActiveSpeedLimit',
closure='&tr_down', closure_cast='*(tr_direction*)',
docstring="Get the active download speed limit")
cls.add_instance_attribute('alt_speed_up', 'int',
is_pure_c=True,
getter='tr_sessionGetAltSpeed_KBps',
setter='tr_sessionSetAltSpeed_KBps',
closure='&tr_up', closure_cast='*(tr_direction*)',
docstring="Get/set the upload alternate speed limit")
cls.add_instance_attribute('alt_speed_down', 'int',
is_pure_c=True,
getter='tr_sessionGetAltSpeed_KBps',
setter='tr_sessionSetAltSpeed_KBps',
closure='&tr_down', closure_cast='*(tr_direction*)',
docstring="Get/set the download alternate speed limit")
cls.add_instance_attribute('alt_speed_begin', 'int',
is_pure_c=True,
getter='tr_sessionGetAltSpeedBegin',
setter='tr_sessionSetAltSpeedBegin',
docstring="Get/set the time (in minutes since midnight) to begin the alt speed")
cls.add_instance_attribute('alt_speed_end', 'int',
is_pure_c=True,
getter='tr_sessionGetAltSpeedEnd',
setter='tr_sessionSetAltSpeedEnd',
docstring="Get/set the time (in minutes since midnight) to end the alt speed")
cls.add_instance_attribute('alt_speed_day', 'tr_sched_day',
is_pure_c=True,
getter='tr_sessionGetAltSpeedDay',
setter='tr_sessionSetAltSpeedDay',
docstring="Get/set the alt speed transmission.scheduled_days")
cls.add_instance_attribute('blocklist_enabled', 'bool',
is_pure_c=True,
getter='tr_blocklistIsEnabled',
setter='tr_blocklistSetEnabled',
docstring="Get/set whether or not to use the peer blocklist")
cls.add_instance_attribute('blocklist_exists', 'bool',
is_const=True,
is_pure_c=True,
getter='tr_blocklistExists',
docstring="Check if the blocklist exists")
cls.add_instance_attribute('blocklist_rule_count', 'int',
is_const=True,
is_pure_c=True,
getter='tr_blocklistGetRuleCount',
docstring="Get/set the number of rules in the blocklist")
cls.add_instance_attribute('blocklist_URL', 'char const *',
is_pure_c=True,
getter='tr_blocklistGetURL',
setter='tr_blocklistSetURL',
docstring="Get/set the blocklist URL")
cls.add_instance_attribute('cache_limit', 'int',
is_pure_c=True,
getter='tr_sessionGetCacheLimit_MB',
setter='tr_sessionSetCacheLimit_MB',
docstring="Get/set the cache limit in MB")
cls.add_instance_attribute('config_directory', 'char const *',
is_const=True,
is_pure_c=True,
getter='tr_sessionGetConfigDir',
docstring="Get the directory used for configuration files")
root_module.header.writeln("tr_session_stats *_wrap_tr_sessionGetCumulativeStats(const tr_session * session);")
root_module.body.writeln("tr_session_stats *_wrap_tr_sessionGetCumulativeStats(const tr_session * session)\n"
"{\n"
" tr_session_stats *stats = tr_new0(tr_session_stats, 1);\n"
" tr_sessionGetCumulativeStats(session, stats);\n"
" return stats;\n"
"}")
cls.add_instance_attribute('cumulative_stats',
ReturnValue.new("tr_session_stats *", caller_owns_return=True),
is_pure_c=True,
is_const=True,
getter='_wrap_tr_sessionGetCumulativeStats',
docstring="Get the total (cumulative) session stats")
cls.add_instance_attribute('delete_source', 'bool',
is_pure_c=True,
getter='tr_sessionGetDeleteSource',
setter='tr_sessionSetDeleteSource',
docstring="")
cls.add_instance_attribute('download_directory', 'char const *',
is_pure_c=True,
getter='tr_sessionGetDownloadDir',
setter='tr_sessionSetDownloadDir',
docstring="Get/set the download directory")
cls.add_instance_attribute('download_directory_free_space', 'int64_t',
is_const=True,
is_pure_c=True,
getter='tr_sessionGetDownloadDirFreeSpace',
docstring="Get the download directory free space")
cls.add_instance_attribute('encryption_mode', 'tr_encryption_mode',
is_pure_c=True,
getter='tr_sessionGetEncryption',
setter='tr_sessionSetEncryption',
docstring="Get/set the session transmission.encryption_mode")
cls.add_instance_attribute('idle_limit', 'uint16_t',
is_pure_c=True,
getter='tr_sessionGetIdleLimit',
setter='tr_sessionSetIdleLimit',
docstring="Get/set the torrent idle limit in minutes")
cls.add_instance_attribute('incomplete_directory', 'char const *',
is_pure_c=True,
getter='tr_sessionGetIncompleteDir',
setter='tr_sessionSetIncompleteDir',
docstring="Get/set the directory for incomplete torrents")
cls.add_instance_attribute('paused', 'bool',
is_pure_c=True,
getter='tr_sessionGetPaused',
setter='tr_sessionSetPaused',
docstring="Pause/unpause the session")
cls.add_instance_attribute('peer_limit', 'uint16_t',
is_pure_c=True,
getter='tr_sessionGetPeerLimit',
setter='tr_sessionSetPeerLimit',
docstring="Get/set the peer limit per session")
cls.add_instance_attribute('peer_limit_per_torrent', 'uint16_t',
is_pure_c=True,
getter='tr_sessionGetPeerLimitPerTorrent',
setter='tr_sessionSetPeerLimitPerTorrent',
docstring="Get/set the peer limit per torrent")
cls.add_instance_attribute('peer_port', 'tr_port',
is_pure_c=True,
getter='tr_sessionGetPeerPort',
setter='tr_sessionSetPeerPort',
docstring="Get/set the peer port")
cls.add_instance_attribute('peer_port_random_on_start', 'bool',
is_pure_c=True,
getter='tr_sessionGetPeerPortRandomOnStart',
setter='tr_sessionSetPeerPortRandomOnStart',
docstring="Get/set whether or not to use a random peer port on start")
cls.add_instance_attribute('port_forwarding', 'tr_port_forwarding',
is_const=True,
is_pure_c=True,
getter='tr_sessionGetPortForwarding',
docstring="Get the session transmission.port_forwarding value")
cls.add_instance_attribute('queue_enabled_up', 'bool',
is_pure_c=True,
getter='tr_sessionGetQueueEnabled',
setter='tr_sessionSetQueueEnabled',
closure='&tr_up', closure_cast='*(tr_direction*)',
docstring="Get/set whether or not to limit how many torrents can upload")
cls.add_instance_attribute('queue_enabled_down', 'bool',
is_pure_c=True,
getter='tr_sessionGetQueueEnabled',
setter='tr_sessionSetQueueEnabled',
closure='&tr_down', closure_cast='*(tr_direction*)',
docstring="Get/set whether or not to limit how many torrents can download")
cls.add_instance_attribute('queue_size_up', 'int',
is_pure_c=True,
getter='tr_sessionGetQueueSize',
setter='tr_sessionSetQueueSize',
closure='&tr_up', closure_cast='*(tr_direction*)',
docstring="Get/set the number of torrents allowed to upload")
cls.add_instance_attribute('queue_size_down', 'int',
is_pure_c=True,
getter='tr_sessionGetQueueSize',
setter='tr_sessionSetQueueSize',
closure='&tr_down', closure_cast='*(tr_direction*)',
docstring="Get/set the number of torrents allowed to download")
cls.add_instance_attribute('queue_stalled_minutes', 'int',
is_pure_c=True,
getter='tr_sessionGetQueueStalledMinutes',
setter='tr_sessionSetQueueStalledMinutes',
docstring="Set whether or not to count torrents idle for over N minutes as `stalled\'")
cls.add_instance_attribute('queue_stalled_enabled', 'bool',
is_pure_c=True,
getter='tr_sessionGetQueueStalledEnabled',
setter='tr_sessionSetQueueStalledEnabled')
cls.add_instance_attribute('RPC_bind_address', 'char const *',
is_const=True,
is_pure_c=True,
getter='tr_sessionGetRPCBindAddress',
docstring="Get/set RPC bind address")
cls.add_instance_attribute('RPC_password', 'char const *',
is_pure_c=True,
getter='tr_sessionGetRPCPassword',
setter='tr_sessionSetRPCPassword',
docstring="Get/set RPC password")
cls.add_instance_attribute('RPC_port', 'tr_port',
is_pure_c=True,
getter='tr_sessionGetRPCPort',
setter='tr_sessionSetRPCPort',
docstring="Get/set RPC port")
cls.add_instance_attribute('RPC_url', 'char const *',
is_pure_c=True,
getter='tr_sessionGetRPCUrl',
setter='tr_sessionSetRPCUrl',
docstring="Get/set RPC URL")
cls.add_instance_attribute('RPC_username', 'char const *',
is_pure_c=True,
getter='tr_sessionGetRPCUsername',
setter='tr_sessionSetRPCUsername',
docstring="Get/set RPC username")
cls.add_instance_attribute('RPC_whitelist', 'char const *',
is_pure_c=True,
getter='tr_sessionGetRPCWhitelist',
setter='tr_sessionSetRPCWhitelist',
docstring="Get/set RPC Access Control List filename")
cls.add_instance_attribute('RPC_whitelist_enabled', 'bool',
is_pure_c=True,
getter='tr_sessionGetRPCWhitelistEnabled',
setter='tr_sessionSetRPCWhitelistEnabled',
docstring="Get/set if session uses the RPC whitelist for allowing/denying RPC requests")
cls.add_instance_attribute('ratio_limit', 'double',
is_pure_c=True,
getter='tr_sessionGetRatioLimit',
setter='tr_sessionSetRatioLimit',
docstring="Get/set the session ratio limit")
cls.add_instance_attribute('raw_speed_up', 'double',
is_pure_c=True,
is_const=True,
getter='tr_sessionGetRawSpeed_KBps',
closure='&tr_up', closure_cast='*(tr_direction*)',
docstring="Get the raw upload speed limit in KBps")
cls.add_instance_attribute('raw_speed_down', 'double',
is_pure_c=True,
is_const=True,
getter='tr_sessionGetRawSpeed_KBps',
closure='&tr_up', closure_cast='*(tr_direction*)',
docstring="Get the raw download speed limit in KBps")
cls.add_instance_attribute('speed_limit_up', 'int',
is_pure_c=True,
getter='tr_sessionGetSpeedLimit_KBps',
setter='tr_sessionSetSpeedLimit_KBps',
closure='&tr_up', closure_cast='*(tr_direction*)',
docstring="Get/set the upload speed limit in KBps")
cls.add_instance_attribute('speed_limit_down', 'int',
is_pure_c=True,
getter='tr_sessionGetSpeedLimit_KBps',
setter='tr_sessionSetSpeedLimit_KBps',
closure='&tr_down', closure_cast='*(tr_direction*)',
docstring="Get/set the download speed limit in KBps")
root_module.header.writeln("tr_session_stats *_wrap_tr_sessionGetStats(const tr_session * session);")
root_module.body.writeln("tr_session_stats *_wrap_tr_sessionGetStats(const tr_session * session)\n"
"{\n"
" tr_session_stats *stats = tr_new0(tr_session_stats, 1);\n"
" tr_sessionGetStats(session, stats);\n"
" return stats;\n"
"}")
cls.add_instance_attribute('stats',
ReturnValue.new("tr_session_stats *", caller_owns_return=True),
is_const=True,
is_pure_c=True,
getter='_wrap_tr_sessionGetStats',
docstring="Get session stats")
cls.add_instance_attribute('torrent_done_script', 'char const *',
is_pure_c=True,
getter='tr_sessionGetTorrentDoneScript',
setter='tr_sessionSetTorrentDoneScript',
docstring="Get/set filename of script to be called on torrent completion")
cls.add_instance_attribute('DHT_enabled', 'bool',
is_pure_c=True,
getter='tr_sessionIsDHTEnabled',
setter='tr_sessionSetDHTEnabled',
docstring="Check/set if session uses DHT")
cls.add_instance_attribute('idle_limited_enabled', 'bool',
is_pure_c=True,
getter='tr_sessionIsIdleLimited',
setter='tr_sessionSetIdleLimited',
docstring="Check/set if session suspends torrent if idle limit is exceded")
cls.add_instance_attribute('incomplete_directory_enabled', 'bool',
is_pure_c=True,
getter='tr_sessionIsIncompleteDirEnabled',
setter='tr_sessionSetIncompleteDirEnabled',
docstring="Check/set if session uses incomplete directory until download is complete")
cls.add_instance_attribute('incomplete_file_naming_enabled', 'bool',
is_pure_c=True,
getter='tr_sessionIsIncompleteFileNamingEnabled',
setter='tr_sessionSetIncompleteFileNamingEnabled',
docstring="Check/set if session appends `.part\' to files until download is complete")
cls.add_instance_attribute('LPD_enabled', 'bool',
is_pure_c=True,
getter='tr_sessionIsLPDEnabled',
setter='tr_sessionSetLPDEnabled',
docstring="Check/set if session uses LPD")
cls.add_instance_attribute('pex_enabled', 'bool',
is_pure_c=True,
getter='tr_sessionIsPexEnabled',
setter='tr_sessionSetPexEnabled',
docstring="Check/set if session uses Pex")
cls.add_instance_attribute('port_forwarding_enabled', 'bool',
is_pure_c=True,
getter='tr_sessionIsPortForwardingEnabled',
setter='tr_sessionSetPortForwardingEnabled',
docstring="Check/set if session uses port forwarding")
cls.add_instance_attribute('RPC_enabled', 'bool',
is_pure_c=True,
getter='tr_sessionIsRPCEnabled',
setter='tr_sessionSetRPCEnabled',
docstring="Check/set if session uses RPC server")
cls.add_instance_attribute('RPC_password_enabled', 'bool',
is_pure_c=True,
getter='tr_sessionIsRPCPasswordEnabled',
setter='tr_sessionSetRPCPasswordEnabled',
docstring="Check/set if RPC server requires password")
cls.add_instance_attribute('ratio_limit_enabled', 'bool',
is_pure_c=True,
getter='tr_sessionIsRatioLimited',
setter='tr_sessionSetRatioLimited',
docstring="Check/set if session is ratio limited")
cls.add_instance_attribute('speed_limit_enabled_up', 'bool',
is_pure_c=True,
getter='tr_sessionIsSpeedLimited',
setter='tr_sessionLimitSpeed',
closure='&tr_up', closure_cast='*(tr_direction*)',
docstring="Check/set if session limits upload speed")
cls.add_instance_attribute('speed_limit_enabled_down', 'bool',
is_pure_c=True,
getter='tr_sessionIsSpeedLimited',
setter='tr_sessionLimitSpeed',
closure='&tr_down', closure_cast='*(tr_direction*)',
docstring="Check/set if session limits download speed")
cls.add_instance_attribute('torrent_done_script_enabled', 'bool',
is_pure_c=True,
getter='tr_sessionIsTorrentDoneScriptEnabled',
setter='tr_sessionSetTorrentDoneScriptEnabled',
docstring="Check/set if session uses calls Session.torrent_done_script")
cls.add_instance_attribute('UTP_enabled', 'bool',
is_pure_c=True,
getter='tr_sessionIsUTPEnabled',
setter='tr_sessionSetUTPEnabled',
docstring="Check/set if session uses UTP")
cls.add_instance_attribute('alt_speed_enabled', 'bool',
is_pure_c=True,
getter='tr_sessionUsesAltSpeed',
setter='tr_sessionUseAltSpeed',
docstring="Check/set if session uses alt speed")
cls.add_instance_attribute('alt_speed_time_enabled', 'bool',
is_pure_c=True,
getter='tr_sessionUsesAltSpeedTime',
setter='tr_sessionUseAltSpeedTime',
docstring="Check/set if session uses alt speed time")
cls.add_function_as_method('tr_sessionReloadBlocklists',
'void',
[param('tr_session *', 'session', transfer_ownership=False)],
custom_name='blocklists_reload',
docstring="Reload blocklists")
cls.add_function_as_method('tr_blocklistSetContent',
'int',
[param('tr_session *', 'session', transfer_ownership=False),
param('char const *', 'filename', default_value='NULL')],
custom_name='blocklist_set',
docstring="Set blocklist content\\n\\n"
"Args:\\n"
" filename (str): blocklist filename or nothing to clear\\n"
"Returns:\\n"
" number of entries added")
cls.add_function_as_method('tr_sessionClearStats',
'void',
[param('tr_session *', 'session', transfer_ownership=False)],
custom_name='stats_clear',
docstring="Clear session stats")
cls.add_function_as_method('tr_sessionSetPeerPortRandom',
'tr_port',
[param('tr_session *', 'session',
transfer_ownership=False)],
custom_name='peer_port_set_random',
docstring="Set incoming peer port to a random port\\n\\n"
"Returns:\\n"
" the port number")
root_module.header.writeln("""void _wrap_alt_speed_callback(tr_session *session, bool active, bool userDriven, void *data);""")
root_module.body.writeln("""
void _wrap_alt_speed_callback(tr_session *session, bool active, bool userDriven, void *data)
{
PyObject *callback = (PyObject*) data;
PyTr_session *py_session = PyObject_New(PyTr_session, &PyTr_session_Type);
py_session->obj = session;
py_session->flags = PYBINDGEN_WRAPPER_FLAG_OBJECT_NOT_OWNED;
PyObject_CallFunction(callback, (char*)"Obb", (PyObject*)py_session, active, userDriven);
Py_DECREF(py_session);
}
""")
cls.add_function_as_method('tr_sessionSetAltSpeedFunc',
'void',
[param('tr_session *', 'session', transfer_ownership=False),
param('tr_altSpeedFunc *', 'callback',
callback_func="_wrap_alt_speed_callback")],
custom_name='alt_speed_function_set',
docstring=
"Function to be called when alternate speed is enabled/disabled\\n\\n"
"Args:\\n"
" callback (function): callable object or function\\n"
" pass `None\' to clear existing callback")
root_module.header.writeln("""tr_rpc_callback_status _wrap_rpc_callback(tr_session *session, tr_rpc_callback_type type, struct tr_torrent *tor, void *data);""")
root_module.body.writeln("""
tr_rpc_callback_status _wrap_rpc_callback(tr_session *session, tr_rpc_callback_type type,
struct tr_torrent *tor, void *data)
{
PyObject *py_torrent, *py_retval;
PyObject *callback = (PyObject*) data;
int retval = 0;
PyTr_session *py_session = PyObject_New(PyTr_session, &PyTr_session_Type);
py_session->obj = session;
py_session->flags = PYBINDGEN_WRAPPER_FLAG_OBJECT_NOT_OWNED;
if (tor) {
PyTr_torrent *tmp = PyObject_New(PyTr_torrent, &PyTr_torrent_Type);
tmp->obj = tor;
tmp->flags = PYBINDGEN_WRAPPER_FLAG_OBJECT_NOT_OWNED;
py_torrent = (PyObject *)tmp;
} else {
Py_INCREF(Py_None);
py_torrent = Py_None;
}
py_retval = PyObject_CallFunction(callback, (char*)"OiO", (PyObject*)py_session, type, py_torrent);
if (py_retval && PyLong_Check(py_retval))
retval = PyLong_AsLong(py_retval);
Py_DECREF(py_session);
Py_DECREF(py_torrent);
Py_DECREF(py_retval);
return retval == (int)TR_RPC_NOREMOVE ? TR_RPC_NOREMOVE : TR_RPC_OK;
}
""")
cls.add_function_as_method('tr_sessionSetRPCCallback',
'void',
[param('tr_session *', 'session', transfer_ownership=False),
param('tr_rpc_func', 'callback', callback_func="_wrap_rpc_callback")],
custom_name='RPC_callback',
docstring=
"Function to be called whenever something is changed via RPC\\n\\n"
"Args:\\n"
" callback (function): callable object or function\\n"
" pass `None\' to clear existing callback")
cls.add_function_as_method('tr_sessionGetSettings',
'void',
[param('tr_session *', 'session', transfer_ownership=False),
BencOutParam('BencDict *', 'dict')],
custom_name='settings',
docstring="Get a `BencDict\' of session settings")
cls.add_function_as_method('tr_sessionLoadTorrents',
retval("tr_torrent **",
array_length='count',
reference_existing_object=True),
[param('tr_session *', 'session', transfer_ownership=False),
param('tr_ctor *', 'torrent_constructor', transfer_ownership=False),
CountParam('int', 'count')],
custom_name='load_torrents',
docstring="Load all the torrents in the torrent directory")
root_module.header.writeln("#define _wrap_tr_torrentNew(s, ctor, err) tr_torrentNew(ctor, err)")
cls.add_function_as_method("_wrap_tr_torrentNew",
ReturnValue.new("tr_torrent *", reference_existing_object=True),
[param('tr_session *', 'session', transfer_ownership=False),
param('tr_ctor *', 'ctor', transfer_ownership=False),
TorrentErrorParam('int', 'setmeError')],
custom_name='torrent_new')
root_module.header.writeln("#define _wrap_tr_torrentFree(s, tor) tr_torrentFree(tor)")
cls.add_function_as_method('_wrap_tr_torrentFree',
'void',
[param('tr_session *', 'session', transfer_ownership=False),
param('tr_torrent *', 'torrent', transfer_ownership=True)],
unblock_threads=True,
custom_name='torrent_free')
root_module.header.writeln("#define _wrap_tr_torrentRemove(s, tor, rem, fn) tr_torrentRemove(tor, rem, fn)")
cls.add_function_as_method('_wrap_tr_torrentRemove',
'void',
[param('tr_session *', 'session', transfer_ownership=False),
param('tr_torrent *', 'torrent', transfer_ownership=True),
param('bool', 'remove_local_data', default_value='0'),
param('NULL', 'removeFunc')],
custom_name='torrent_remove')
cls.add_custom_method_wrapper('torrents',
'_wrap_tr_torrentList',
flags=["METH_NOARGS"],
wrapper_body="""
static PyObject* _wrap_tr_torrentList(PyTr_session *self, PyObject **return_exception)
{
tr_torrent *torrent = NULL;
PyObject *py_list = PyList_New(0);
while ((torrent = tr_torrentNext(self->obj, torrent)) != NULL) {
PyTr_torrent *elem = PyObject_New(PyTr_torrent, &PyTr_torrent_Type);
elem->obj = torrent;
elem->flags = PYBINDGEN_WRAPPER_FLAG_OBJECT_NOT_OWNED;
PyList_Append(py_list, (PyObject*)elem);
}
return py_list;
}
""")
cls.add_function_as_method('tr_sessionSaveSettings',
'void',
[param('tr_session *', 'session', transfer_ownership=False),
param('char const *', 'directory'),
param('BencDict const *', 'settings', transfer_ownership=False)],
custom_name='settings_save',
docstring="Save `settings\' to `directory\'")
cls.add_function_as_method('tr_sessionSet',
'void',
[param('tr_session *', 'session', transfer_ownership=False),
param('BencDict *', 'settings', transfer_ownership=False)],
custom_name='update',
docstring="Update session settings from `BencDict\'")
return
def my_module_gen(out_file):
mod = Module('foo')
foomodulegen_common.customize_module_pre(mod)
mod.add_include('"foo.h"')
mod.add_function('TypeNameGet',
'std::string', [],
custom_name='IntegerTypeNameGet',
template_parameters=['int'])
Foo = mod.add_class('Foo', automatic_type_narrowing=True)
Foo.add_static_attribute('instance_count', ReturnValue.new('int'))
Foo.add_constructor([Parameter.new('std::string', 'datum')])
Foo.add_constructor([])
Foo.add_constructor([Parameter.new('const Foo&', 'foo')])
Foo.add_method('get_datum', ReturnValue.new('const std::string'), [])
Foo.add_method('is_initialized',
ReturnValue.new('bool'), [],
is_const=True)
Foo.add_output_stream_operator()
Foo.add_method('add_sub',
ReturnValue.new('int'), [
Parameter.new('int', 'a'),
Parameter.new('int', 'b', default_value='3'),
Parameter.new('bool', 'subtract', default_value='false')
],
is_static=True)
Foo.add_custom_instance_attribute("is_unique",
"bool",
getter="is_unique",
is_const=True)
Zoo = mod.add_class('Zoo', automatic_type_narrowing=True)
Zoo.add_constructor([Parameter.new('std::string', 'datum')])
Zoo.add_constructor([])
Zoo.add_method('get_datum', ReturnValue.new('std::string'), [])
Zoo.implicitly_converts_to(Foo)
Foobar = mod.add_class('Foobar', allow_subclassing=True)
Foobar.add_static_attribute('instance_count', ReturnValue.new('int'))
Bar = mod.add_class('Bar', parent=Foo)
Bar.inherit_default_constructors()
## a static method..
Bar.add_method('Hooray',
ReturnValue.new('std::string'), [],
is_static=True)
## to test RTTI with a hidden subclass
mod.add_function('get_hidden_subclass_pointer',
ReturnValue.new('Foo*', caller_owns_return=True), [])
## Zbr is a reference counted class
Zbr = mod.add_class('Zbr',
memory_policy=cppclass.ReferenceCountingMethodsPolicy(
incref_method='Ref',
decref_method='Unref',
peekref_method="GetReferenceCount"),
allow_subclassing=True)
def helper_class_hook(helper_class):
helper_class.add_custom_method(
declaration="static int custom_method_added_by_a_hook(int x);",
body="""
int %s::custom_method_added_by_a_hook(int x)
{
return x + 1;
}
""" % helper_class.name)
helper_class.add_post_generation_code(
"// this comment was written by a helper class hook function")
Zbr.add_helper_class_hook(helper_class_hook)
Zbr.add_constructor([])
Zbr.add_constructor([Parameter.new('std::string', 'datum')])
Zbr.add_method('get_datum', ReturnValue.new('std::string'), [])
Zbr.add_method('get_int',
ReturnValue.new('int'), [Parameter.new('int', 'x')],
is_virtual=True)
Zbr.add_static_attribute('instance_count', ReturnValue.new('int'))
Zbr.add_method(
'get_value', ReturnValue.new('int'),
[Parameter.new('int*', 'x', direction=Parameter.DIRECTION_OUT)])
mod.add_function('store_zbr', None,
[Parameter.new('Zbr*', 'zbr', transfer_ownership=True)])
mod.add_function('invoke_zbr', ReturnValue.new('int'),
[Parameter.new('int', 'x')])
mod.add_function('delete_stored_zbr', None, [])
mod.add_function('print_something',
ReturnValue.new('int'),
[Parameter.new('const char*', 'message')],
deprecated=True)
mod.add_function('print_something_else', ReturnValue.new('int'),
[Parameter.new('const char*', 'message2')])
## test overloaded functions
mod.add_function('get_int_from_string',
ReturnValue.new('int'), [
Parameter.new('const char*', 'from_string'),
Parameter.new('int', 'multiplier', default_value='1')
],
custom_name="get_int")
mod.add_function('get_int_from_float',
ReturnValue.new('int'), [
Parameter.new('double', 'from_float'),
Parameter.new('int', 'multiplier', default_value='1')
],
custom_name="get_int")
## test free_after_copy.
mod.add_function('return_c_string_to_be_freed',
ReturnValue.new('char *', free_after_copy=True),
[Parameter.new('int', 'size')])
mod.add_function('return_c_string_to_not_be_freed',
ReturnValue.new('char *', free_after_copy=False),
[Parameter.new('int', 'size')])
ToBeFreed = mod.add_class('ToBeFreed')
ToBeFreed.add_constructor([Parameter.new('int', 'size')])
ToBeFreed.add_copy_constructor()
ToBeFreed.add_method('value', ReturnValue.new('char *'), [])
mod.add_function('return_class_to_be_freed',
ReturnValue.new('ToBeFreed *', free_after_copy=True),
[Parameter.new('int', 'size')])
mod.add_function('return_class_to_not_be_freed',
ReturnValue.new('ToBeFreed *', free_after_copy=False),
[Parameter.new('int', 'size')])
SomeObject = mod.add_class('SomeObject', allow_subclassing=True)
SomeObject.add_instance_attribute('foo',
ReturnValue.new('Foo'),
getter='get_foo_value',
setter='set_foo_value')
SomeObject.add_instance_attribute('m_prefix',
ReturnValue.new('std::string'))
SomeObject.add_static_attribute('staticData',
ReturnValue.new('std::string'))
SomeObject.add_static_attribute('instance_count', ReturnValue.new('int'))
SomeObject.add_method('add_prefix', ReturnValue.new('int'), [
Parameter.new(
'std::string&', 'message', direction=Parameter.DIRECTION_INOUT)
])
SomeObject.add_constructor([Parameter.new('std::string', 'prefix')])
SomeObject.add_constructor([Parameter.new('int', 'prefix_len')])
SomeObject.add_method(
'operator()',
ReturnValue.new('int'), [
Parameter.new(
'std::string&', 'message', direction=Parameter.DIRECTION_INOUT)
],
custom_name='__call__')
# --- some virtual methods ---
SomeObject.add_method('get_prefix',
ReturnValue.new('std::string'), [],
is_virtual=True,
is_const=True)
SomeObject.add_method('get_prefix_with_foo_value',
ReturnValue.new('std::string'),
[Parameter.new('Foo', 'foo')],
is_virtual=True,
is_const=True)
SomeObject.add_method(
'get_prefix_with_foo_ref',
ReturnValue.new('std::string'), [
Parameter.new(
'const Foo&', 'foo', direction=Parameter.DIRECTION_INOUT)
],
is_virtual=True,
is_const=True)
SomeObject.add_method(
'get_prefix_with_foo_ptr',
ReturnValue.new('std::string'),
[Parameter.new('const Foo*', 'foo', transfer_ownership=False)],
is_virtual=True,
is_const=True)
## overloaded virtual methods
SomeObject.add_method('get_something',
ReturnValue.new('std::string'), [],
is_virtual=True,
is_const=True)
SomeObject.add_method('get_something',
ReturnValue.new('std::string'),
[Parameter.new('int', 'x')],
is_virtual=True,
is_const=True)
SomeObject.add_method(
'set_pyobject',
None,
[Parameter.new('PyObject*', 'pyobject', transfer_ownership=False)],
is_virtual=True)
SomeObject.add_method('get_pyobject',
ReturnValue.new('PyObject*',
caller_owns_return=True), [],
is_virtual=True)
## add a function that appears as a method of an object
SomeObject.add_function_as_method(
'some_object_get_something_prefixed',
ReturnValue.new('std::string'), [
Parameter.new('const SomeObject*', 'obj',
transfer_ownership=False),
Parameter.new('std::string', 'something')
],
custom_name='get_something_prefixed')
## add a function that appears as a method of an object
SomeObject.add_function_as_method(
'some_object_val_get_something_prefixed',
ReturnValue.new('std::string'), [
Parameter.new('SomeObject', 'obj'),
Parameter.new('std::string', 'something')
],
custom_name='val_get_something_prefixed')
## add a function that appears as a method of an object
SomeObject.add_function_as_method(
'some_object_ref_get_something_prefixed',
ReturnValue.new('std::string'), [
Parameter.new('const SomeObject&', 'obj'),
Parameter.new('std::string', 'something')
],
custom_name='ref_get_something_prefixed')
# ---
SomeObject.add_method('call_get_prefix', ReturnValue.new('std::string'),
[])
SomeObject.add_method('set_foo_value', None, [Parameter.new('Foo', 'foo')])
SomeObject.add_method('get_foo_value', ReturnValue.new('Foo'), [])
SomeObject.add_method(
'set_foo_ptr', ReturnValue.new('void'),
[Parameter.new('Foo*', 'foo', transfer_ownership=True)])
SomeObject.add_method(
'set_foo_shared_ptr', ReturnValue.new('void'),
[Parameter.new('Foo*', 'foo', transfer_ownership=False)])
SomeObject.add_method(
'get_foo_shared_ptr',
ReturnValue.new('const Foo*', caller_owns_return=False), [])
SomeObject.add_method('get_foo_ptr',
ReturnValue.new('Foo*', caller_owns_return=True), [])
SomeObject.add_method(
'set_foo_by_ref', ReturnValue.new('void'),
[Parameter.new('Foo&', 'foo', direction=Parameter.DIRECTION_IN)])
SomeObject.add_method(
'get_foo_by_ref', ReturnValue.new('void'),
[Parameter.new('Foo&', 'foo', direction=Parameter.DIRECTION_OUT)])
## custodian/ward tests
SomeObject.add_method(
'get_foobar_with_self_as_custodian',
ReturnValue.new('Foobar*', custodian=0,
reference_existing_object=True), [])
SomeObject.add_method(
'get_foobar_with_other_as_custodian',
ReturnValue.new('Foobar*', custodian=1,
reference_existing_object=True),
[Parameter.new('SomeObject*', 'other', transfer_ownership=False)])
SomeObject.add_method(
'set_foobar_with_self_as_custodian', ReturnValue.new('void'), [
Parameter.new(
'Foobar*', 'foobar', transfer_ownership=True, custodian=0)
])
mod.add_function(
'get_foobar_with_other_as_custodian',
ReturnValue.new('Foobar*', custodian=1,
reference_existing_object=True),
[Parameter.new('SomeObject*', 'other', transfer_ownership=False)])
mod.add_function('create_new_foobar',
ReturnValue.new('Foobar*', caller_owns_return=True), [])
mod.add_function(
'set_foobar_with_other_as_custodian', ReturnValue.new('void'), [
Parameter.new(
'Foobar*', 'foobar', transfer_ownership=True, custodian=2),
Parameter.new('SomeObject*', 'other', transfer_ownership=False)
])
mod.add_function(
'set_foobar_with_return_as_custodian',
ReturnValue.new('SomeObject*', caller_owns_return=True), [
Parameter.new(
'Foobar*', 'foobar', transfer_ownership=True, custodian=-1)
])
## get/set recfcounted object Zbr
SomeObject.add_method('get_zbr',
ReturnValue.new('Zbr*', caller_owns_return=True), [])
SomeObject.add_method('get_internal_zbr',
ReturnValue.new('Zbr*', caller_owns_return=True), [])
SomeObject.add_method('peek_zbr',
ReturnValue.new('Zbr*', caller_owns_return=False),
[])
SomeObject.add_method(
'set_zbr_transfer', ReturnValue.new('void'),
[Parameter.new('Zbr*', 'zbr', transfer_ownership=True)])
SomeObject.add_method(
'set_zbr_shared', ReturnValue.new('void'),
[Parameter.new('Zbr*', 'zbr', transfer_ownership=False)])
## methods with transformed types
SomeObject.add_method('set_zbr_pholder', ReturnValue.new('void'),
[Parameter.new('PointerHolder<Zbr>', 'zbr')])
SomeObject.add_method('get_zbr_pholder',
ReturnValue.new('PointerHolder<Zbr>'), [])
## test overloaded methods
SomeObject.add_method('get_int',
ReturnValue.new('int'),
[Parameter.new('const char*', 'from_string')],
custom_name="get_int")
SomeObject.add_method('get_int',
ReturnValue.new('int'),
[Parameter.new('double', 'from_float')],
custom_name="get_int")
# Bug #508577
SomeObject.add_method('protected_method_that_is_not_virtual',
ReturnValue.new('std::string'),
[Parameter.new('std::string', 'arg')],
is_const=True,
visibility='protected')
SomeObject.add_method('method_returning_cstring',
ReturnValue.new('const char *'), [],
is_virtual=True,
is_const=True)
mod.add_function(
'store_some_object', ReturnValue.new('void'),
[Parameter.new('SomeObject*', 'obj', transfer_ownership=True)])
mod.add_function('invoke_some_object_get_prefix',
ReturnValue.new('std::string'), [])
mod.add_function('take_some_object',
ReturnValue.new('SomeObject*', caller_owns_return=True),
[])
mod.add_function('delete_some_object', ReturnValue.new('void'), [])
xpto = mod.add_cpp_namespace("xpto")
xpto.add_function('some_function', ReturnValue.new('std::string'), [])
## enums..
xpto.add_enum('FooType', ['FOO_TYPE_AAA', 'FOO_TYPE_BBB', 'FOO_TYPE_CCC'])
xpto.add_function('get_foo_type', ReturnValue.new('FooType'), [])
xpto.add_function('set_foo_type', ReturnValue.new('void'),
[Parameter.new("FooType", 'type')])
xpto.add_function('set_foo_type_inout', ReturnValue.new('void'), [
Parameter.new("FooType&", 'type', direction=Parameter.DIRECTION_INOUT)
])
xpto.add_function('set_foo_type_ptr', ReturnValue.new('void'), [
Parameter.new("FooType*", 'type', direction=Parameter.DIRECTION_INOUT)
])
xpto_SomeClass = xpto.add_class(
'SomeClass', docstring="This is the docstring for SomeClass")
xpto_SomeClass.add_constructor([])
xpto.add_typedef(Foo, 'FooXpto')
xpto.add_function('get_foo_datum', 'std::string',
[Parameter.new('const xpto::FooXpto&', 'foo')])
typehandlers.add_type_alias('uint32_t', 'xpto::FlowId')
xpto.add_function('get_flow_id', 'xpto::FlowId',
[Parameter.new('xpto::FlowId', 'flowId')])
# bug #798383
XptoClass = xpto.add_struct('XptoClass')
XptoClass.add_method("GetSomeClass",
retval("xpto::SomeClass*", caller_owns_return=True),
[])
## ---- some implicity conversion APIs
mod.add_function('function_that_takes_foo', ReturnValue.new('void'),
[Parameter.new('Foo', 'foo')])
mod.add_function('function_that_returns_foo', ReturnValue.new('Foo'), [])
cls = mod.add_class('ClassThatTakesFoo')
cls.add_constructor([Parameter.new('Foo', 'foo')])
cls.add_method('get_foo', ReturnValue.new('Foo'), [])
cls = mod.add_class('SingletonClass', is_singleton=True)
cls.add_method('GetInstance',
ReturnValue.new('SingletonClass*', caller_owns_return=True),
[],
is_static=True)
## A class that has no public default constructor...
cls = mod.add_class('InterfaceId', is_singleton=True)
## A function that returns such a class...
mod.add_function('make_interface_id', ReturnValue.new('InterfaceId'), [])
## A class the cannot be constructed; this will cause late CodeGenerationError's
cls = mod.add_class('CannotBeConstructed')
cls.set_cannot_be_constructed("no reason")
cls.add_method('get_value',
ReturnValue.new('CannotBeConstructed'), [],
is_static=True)
cls.add_method('get_ptr',
ReturnValue.new('CannotBeConstructed*',
caller_owns_return=True), [],
is_static=True)
mod.add_function('get_cannot_be_constructed_value',
ReturnValue.new('CannotBeConstructed'), [])
mod.add_function(
'get_cannot_be_constructed_ptr',
ReturnValue.new('CannotBeConstructed*', caller_owns_return=True), [])
## A nested class
#NestedClass = mod.add_class('NestedClass', automatic_type_narrowing=True, outer_class=SomeObject)
NestedClass = SomeObject.add_class('NestedClass',
automatic_type_narrowing=True)
NestedClass.add_static_attribute('instance_count', ReturnValue.new('int'))
NestedClass.add_constructor([Parameter.new('std::string', 'datum')])
NestedClass.add_constructor([])
NestedClass.add_method('get_datum', ReturnValue.new('std::string'), [])
## A nested enum..
#mod.add_enum('NestedEnum', ['FOO_TYPE_AAA', 'FOO_TYPE_BBB', 'FOO_TYPE_CCC'], outer_class=SomeObject)
SomeObject.add_enum('NestedEnum',
['FOO_TYPE_AAA', 'FOO_TYPE_BBB', 'FOO_TYPE_CCC'])
## anonymous enum
SomeObject.add_enum('', ['CONSTANT_A', 'CONSTANT_B', 'CONSTANT_C'])
AbstractBaseClass2 = mod.add_class('AbstractBaseClass2',
allow_subclassing=True)
AbstractBaseClass2.add_method('invoke_private_virtual',
ReturnValue.new('int'),
[Parameter.new('int', 'x')],
is_const=True)
AbstractBaseClass2.add_method('invoke_protected_virtual',
ReturnValue.new('int'),
[Parameter.new('int', 'x')],
is_const=True)
AbstractBaseClass2.add_method('invoke_protected_pure_virtual',
ReturnValue.new('int'),
[Parameter.new('int', 'x')],
is_const=True)
AbstractBaseClass2.add_constructor([], visibility='protected')
AbstractBaseClass2.add_method('protected_virtual',
ReturnValue.new('int'),
[Parameter.new('int', 'x')],
is_virtual=True,
visibility='protected',
is_const=True)
AbstractBaseClass2.add_method('protected_pure_virtual',
ReturnValue.new('int'),
[Parameter.new('int', 'x')],
is_virtual=True,
is_pure_virtual=True,
visibility='protected',
is_const=True)
AbstractBaseClass2.add_method('private_virtual',
ReturnValue.new('int'),
[Parameter.new('int', 'x')],
is_virtual=True,
is_pure_virtual=True,
visibility='private',
is_const=True)
AbstractXpto = mod.add_class('AbstractXpto', allow_subclassing=True)
AbstractXpto.add_method('something',
ReturnValue.new('void'),
[Parameter.new('int', 'x')],
is_const=True,
is_virtual=True,
is_pure_virtual=True)
AbstractXpto.add_constructor([])
AbstractXptoImpl = mod.add_class('AbstractXptoImpl', parent=AbstractXpto)
AbstractXptoImpl.add_method('something',
ReturnValue.new('void'),
[Parameter.new('int', 'x')],
is_const=True,
is_virtual=True,
is_pure_virtual=False)
AbstractXptoImpl.add_constructor([])
Word = mod.add_class('Word')
Word.add_instance_attribute('low', 'uint8_t', is_const=False)
Word.add_instance_attribute('high', 'uint8_t', is_const=False)
Word.add_instance_attribute('word', 'uint16_t', is_const=False)
Word.add_constructor([])
mod.add_function('matrix_sum_of_elements', ReturnValue.new('float'), [
Parameter.new("float*",
'matrix',
direction=Parameter.DIRECTION_IN,
array_length=6)
])
mod.add_function('matrix_identity_new', ReturnValue.new('void'), [
Parameter.new("float*",
'matrix',
direction=Parameter.DIRECTION_OUT,
array_length=6)
])
top_ns = mod.add_cpp_namespace('TopNs')
outer_base = top_ns.add_class('OuterBase')
bottom_ns = top_ns.add_cpp_namespace('PrefixBottomNs')
inner = bottom_ns.add_class('PrefixInner', parent=outer_base)
inner.add_constructor([])
inner.add_method('Do', 'void', [])
Socket = mod.add_class('Socket', allow_subclassing=True)
Socket.add_constructor([])
Socket.add_method('Bind', ReturnValue.new('int'), [], is_virtual=True)
Socket.add_method('Bind',
ReturnValue.new('int'),
[Parameter.new('int', 'address')],
is_virtual=True)
UdpSocket = mod.add_class('UdpSocket', parent=Socket)
UdpSocket.add_constructor([])
UdpSocket.add_method('Bind', ReturnValue.new('int'), [], is_virtual=True)
simple_struct_t = mod.add_struct('simple_struct_t')
simple_struct_t.add_instance_attribute('xpto', 'int')
# containers...
mod.add_container('SimpleStructList', ReturnValue.new('simple_struct_t'),
'list')
mod.add_function('get_simple_list', ReturnValue.new('SimpleStructList'),
[])
mod.add_function('set_simple_list', 'int',
[Parameter.new('SimpleStructList', 'list')])
mod.add_container('std::set<float>', 'float', 'set')
TestContainer = mod.add_class('TestContainer', allow_subclassing=True)
TestContainer.add_constructor([])
TestContainer.add_instance_attribute('m_floatSet', 'std::set<float>')
TestContainer.add_method('get_simple_list',
ReturnValue.new('SimpleStructList'), [],
is_virtual=True)
TestContainer.add_method('set_simple_list',
'int',
[Parameter.new('SimpleStructList', 'list')],
is_virtual=True)
TestContainer.add_method(
'set_simple_list_by_ref',
'int', [
Parameter.new('SimpleStructList&',
'inout_list',
direction=Parameter.DIRECTION_INOUT)
],
is_virtual=True)
mod.add_container('std::vector<simple_struct_t>',
ReturnValue.new('simple_struct_t'), 'vector')
TestContainer.add_method('get_simple_vec',
ReturnValue.new('std::vector<simple_struct_t>'),
[],
is_virtual=True)
TestContainer.add_method(
'set_simple_vec',
'int', [Parameter.new('std::vector<simple_struct_t>', 'vec')],
is_virtual=True)
mod.add_container('std::vector<std::string>', 'std::string', 'vector')
TestContainer.add_method('get_vec', 'void', [
Parameter.new('std::vector<std::string> &',
'outVec',
direction=Parameter.DIRECTION_OUT)
])
TestContainer.add_method('set_vec_ptr', 'void', [
Parameter.new('std::vector<std::string>*',
'inVec',
direction=Parameter.DIRECTION_IN,
transfer_ownership=True)
])
TestContainer.add_method('get_vec_ptr', 'void', [
Parameter.new('std::vector<std::string>*',
'outVec',
direction=Parameter.DIRECTION_OUT)
])
mod.add_container(
'std::map<std::string, simple_struct_t>',
(ReturnValue.new('std::string'), ReturnValue.new('simple_struct_t')),
'map')
TestContainer.add_method(
'get_simple_map',
ReturnValue.new('std::map<std::string, simple_struct_t>'), [],
is_virtual=True)
TestContainer.add_method(
'set_simple_map',
'int',
[Parameter.new('std::map<std::string, simple_struct_t>', 'map')],
is_virtual=True)
mod.add_container('SimpleStructUnorderedMap',
('std::string', 'simple_struct_t'),
container_type='map')
typehandlers.add_type_alias(
'std::unordered_map< std::string, simple_struct_t >',
'SimpleStructUnorderedMap')
typehandlers.add_type_alias(
'std::unordered_map< std::string, simple_struct_t >*',
'SimpleStructUnorderedMap*')
typehandlers.add_type_alias(
'std::unordered_map< std::string, simple_struct_t >&',
'SimpleStructUnorderedMap&')
TestContainer.add_method(
'get_simple_unordered_map',
ReturnValue.new('std::unordered_map<std::string, simple_struct_t>'),
[],
is_virtual=True)
TestContainer.add_method(
'set_simple_unordered_map',
'int', [
Parameter.new('std::unordered_map<std::string, simple_struct_t>',
'map')
],
is_virtual=True)
Tupl = mod.add_class('Tupl')
Tupl.add_binary_comparison_operator('<')
Tupl.add_binary_comparison_operator('<=')
Tupl.add_binary_comparison_operator('>=')
Tupl.add_binary_comparison_operator('>')
Tupl.add_binary_comparison_operator('==')
Tupl.add_binary_comparison_operator('!=')
Tupl.add_binary_numeric_operator('+')
Tupl.add_binary_numeric_operator('-')
Tupl.add_binary_numeric_operator('*')
Tupl.add_binary_numeric_operator('/')
Tupl.add_instance_attribute('x', 'int', is_const=False)
Tupl.add_instance_attribute('y', 'int', is_const=False)
Tupl.add_constructor([Parameter.new('Tupl const &', 'arg0')])
Tupl.add_constructor([])
Tupl.add_inplace_numeric_operator('+=')
Tupl.add_inplace_numeric_operator('-=')
Tupl.add_inplace_numeric_operator('*=')
Tupl.add_inplace_numeric_operator('/=')
Tupl.add_unary_numeric_operator('-')
Tupl.add_inplace_numeric_operator('+=', right='int')
ManipulatedObject = mod.add_class('ManipulatedObject')
ManipulatedObject.add_constructor([])
ManipulatedObject.add_method('GetValue', 'int', [], is_const=True)
ManipulatedObject.add_method('SetValue', 'void',
[Parameter.new('int', 'value')])
ReferenceManipulator = mod.add_class('ReferenceManipulator',
allow_subclassing=True)
ReferenceManipulator.add_constructor([])
ReferenceManipulator.add_method('manipulate_object', 'int', [])
ReferenceManipulator.add_method(
'do_manipulate_object',
'void', [
Parameter.new('ManipulatedObject&',
'obj',
direction=Parameter.DIRECTION_INOUT)
],
is_virtual=True,
is_pure_virtual=True)
VectorLike = mod.add_class('VectorLike')
VectorLike.add_constructor([])
VectorLike.add_constructor([Parameter.new("VectorLike&", "obj")])
VectorLike.add_method('get_len', 'size_t', [], custom_name='__len__')
VectorLike.add_method('add_VectorLike',
'VectorLike', [Parameter.new('VectorLike', 'rhs')],
custom_name='__add__')
VectorLike.add_method('iadd_VectorLike',
'VectorLike', [Parameter.new('VectorLike', 'rhs')],
custom_name='__iadd__')
VectorLike.add_method('mul_VectorLike',
'VectorLike', [Parameter.new('unsigned int', 'n')],
custom_name='__mul__')
VectorLike.add_method('imul_VectorLike',
'VectorLike', [Parameter.new('unsigned int', 'n')],
custom_name='__imul__')
VectorLike.add_method(
'set_item',
'int',
[Parameter.new('int', 'index'),
Parameter.new('double', 'value')],
custom_name='__setitem__')
VectorLike.add_method('get_item',
'double', [Parameter.new('int', 'index')],
custom_name='__getitem__')
VectorLike.add_method('set_slice',
'int', [
Parameter.new('int', 'index1'),
Parameter.new('int', 'index2'),
Parameter.new('VectorLike', 'values')
],
custom_name='__setslice__')
VectorLike.add_method(
'get_slice',
'VectorLike',
[Parameter.new('int', 'index1'),
Parameter.new('int', 'index2')],
custom_name='__getslice__')
VectorLike.add_method('contains_value',
'int', [Parameter.new('double', 'value')],
custom_name='__contains__')
VectorLike.add_method('append', 'void', [Parameter.new('double', 'value')])
VectorLike2 = mod.add_class('VectorLike2')
VectorLike2.add_constructor([])
VectorLike2.add_method('append', 'void',
[Parameter.new('double', 'value')])
MapLike = mod.add_class('MapLike')
MapLike.add_constructor([])
MapLike.add_method(
'set', 'void',
[Parameter.new('int', 'key'),
Parameter.new('double', 'value')])
Error = mod.add_exception('Error')
DomainError = mod.add_exception('DomainError', parent=Error)
mod.add_function('my_inverse_func',
'double', [Parameter.new('double', 'x')],
throw=[DomainError])
ClassThatThrows = mod.add_class('ClassThatThrows', allow_subclassing=True)
ClassThatThrows.add_constructor([Parameter.new('double', 'x')],
throw=[DomainError])
ClassThatThrows.add_method('my_inverse_method',
'double', [Parameter.new('double', 'x')],
throw=[DomainError])
std_exception = mod.add_exception('exception',
foreign_cpp_namespace='std',
message_rvalue='%(EXC)s.what()')
mod.add_function('my_inverse_func2',
'double', [Parameter.new('double', 'x')],
throw=[std_exception])
ClassThatThrows.add_method('my_inverse_method2',
'double', [Parameter.new('double', 'x')],
throw=[std_exception])
mod.add_function('my_inverse_func3',
'double', [Parameter.new('double', 'x')],
throw=[std_exception])
ClassThatThrows.add_method('my_inverse_method3',
'double', [Parameter.new('double', 'x')],
throw=[std_exception])
ClassThatThrows.add_method('throw_error',
'int', [],
throw=[mod["out_of_range"]],
is_const=True,
is_virtual=True)
ClassThatThrows.add_method('throw_out_of_range',
'int', [],
throw=[mod["out_of_range"]])
# https://bugs.launchpad.net/pybindgen/+bug/450255
ProtectedConstructor = mod.add_class('ProtectedConstructor')
ProtectedConstructor.add_constructor([])
ProtectedConstructor.add_constructor(
[Parameter.new('ProtectedConstructor&', 'c')], visibility='protected')
# https://bugs.launchpad.net/pybindgen/+bug/455689
property_std_string = mod.add_struct('property',
template_parameters=['std::string'])
Box = mod.add_class('Box')
Box.add_constructor([])
Box.add_static_attribute('instance_count', ReturnValue.new('int'))
Box.add_method(
'getFoobarInternalPtr',
ReturnValue.new('const Foobar*', reference_existing_object=True), [])
Box.add_method('getFoobarInternalRef',
ReturnValue.new('Foobar&', reference_existing_object=True),
[])
Box.add_method('getFoobarInternalPtr2',
ReturnValue.new('Foobar*', return_internal_reference=True),
[])
Box.add_method('getFoobarInternalRef2',
ReturnValue.new('Foobar&', return_internal_reference=True),
[])
Box.add_instance_attribute(
'm_internalFoobar',
ReturnValue.new('Foobar*', reference_existing_object=True))
# multiple inheritance
MIRoot = mod.add_class('MIRoot')
MIRoot.add_constructor([])
MIRoot.add_method('root_method', 'int', [], is_const=True)
MIBase1 = mod.add_class('MIBase1', parent=MIRoot)
MIBase1.add_constructor([])
MIBase1.add_method('base1_method', 'int', [], is_const=True)
MIBase2 = mod.add_class('MIBase2', parent=MIRoot)
MIBase2.add_constructor([])
MIBase2.add_method('base2_method', 'int', [], is_const=True)
MIMixed = mod.add_class('MIMixed', parent=[MIBase1, MIBase2])
MIMixed.add_constructor([])
MIMixed.add_method('mixed_method', 'int', [], is_const=True)
mod.add_function('my_throwing_func', 'Tupl', [], throw=[std_exception])
IFoo = mod.add_class("IFoo",
destructor_visibility='protected',
allow_subclassing=True)
IFoo.add_method("DoSomething", None, [], is_pure_virtual=True)
IFooImpl = mod.add_class("IFooImpl",
parent=IFoo,
destructor_visibility='public')
IFooImpl.add_constructor([])
IFooImpl.add_method("DoSomething", None, [], is_virtual=True)
mod.add_function(
"test_args_kwargs", "int",
[param("const char *", "args"),
param("const char *", "kwargs")])
# https://github.com/gjcarneiro/pybindgen/issues/21
cls = mod.add_class('RAStruct')
cls.add_constructor([])
cls.add_constructor([param('RAStruct const &', 'arg0')])
cls.add_instance_attribute('a', 'int', is_const=False)
cls = mod.add_class('ReturnConstRef', allow_subclassing=True)
cls.add_constructor([])
cls.add_constructor([param('ReturnConstRef const &', 'arg0')])
cls.add_method('ReturnMyAStruct',
'RAStruct const &', [],
is_pure_virtual=True,
is_virtual=True)
cls = mod.add_class('RAReturnConstRef', parent=mod['ReturnConstRef'])
cls.add_constructor([])
cls.add_constructor([param('int', 'value')])
cls.add_constructor([param('RAReturnConstRef const &', 'arg0')])
cls.add_method('ReturnMyAStruct', 'RAStruct const &', [], is_virtual=True)
#### --- error handler ---
class MyErrorHandler(pybindgen.settings.ErrorHandler):
def __init__(self):
super(MyErrorHandler, self).__init__()
self.num_errors = 0
def handle_error(self, wrapper, exception, traceback_):
print("exception %s in wrapper %s" % (exception, wrapper),
file=sys.stderr)
self.num_errors += 1
if 0: # verbose?
import traceback
traceback.print_tb(traceback_)
return True
pybindgen.settings.error_handler = MyErrorHandler()
foomodulegen_common.customize_module(mod)
## ---- finally, generate the whole thing ----
mod.generate(FileCodeSink(out_file))
def register_Tr_session_methods(root_module, cls):
cls.docstring = (
'Class that manages the Transmission session\\n'
'\\n'
'Args:\\n'
' tag (str): \'gtk\', \'macosx\', \'daemon\', etc...\\n'
' this is only for pre-1.30 resume files\\n'
' config_dir (str): directory for configuration files\\n'
' message_queueing (bool): if True, messages will be queued\\n'
' settings (BencDict): session settings')
con = cls.add_function_as_constructor(
"tr_sessionInit",
ReturnValue.new("tr_session *", caller_owns_return=True), [
param('const char *', 'tag'),
param('const char *', 'config_dir'),
param('bool', 'message_queueing'),
param('BencDict *', 'settings', transfer_ownership=False)
])
root_module.header.writeln(
"double _wrap_tr_sessionGetActiveSpeedLimit(const tr_session *session,\n"
" tr_direction dir);")
root_module.body.writeln(
"double _wrap_tr_sessionGetActiveSpeedLimit(const tr_session *session,\n"
" tr_direction dir)\n"
"{\n"
" double speed;\n"
" if (tr_sessionGetActiveSpeedLimit_KBps(session, dir, &speed))\n"
" return speed;\n"
" return -1;\n"
"}")
cls.add_instance_attribute('active_speed_limit_up',
'double',
is_const=True,
is_pure_c=True,
getter='_wrap_tr_sessionGetActiveSpeedLimit',
closure='&tr_up',
closure_cast='*(tr_direction*)',
docstring="Get the active upload speed limit")
cls.add_instance_attribute('active_speed_limit_down',
'double',
is_const=True,
is_pure_c=True,
getter='_wrap_tr_sessionGetActiveSpeedLimit',
closure='&tr_down',
closure_cast='*(tr_direction*)',
docstring="Get the active download speed limit")
cls.add_instance_attribute(
'alt_speed_up',
'int',
is_pure_c=True,
getter='tr_sessionGetAltSpeed_KBps',
setter='tr_sessionSetAltSpeed_KBps',
closure='&tr_up',
closure_cast='*(tr_direction*)',
docstring="Get/set the upload alternate speed limit")
cls.add_instance_attribute(
'alt_speed_down',
'int',
is_pure_c=True,
getter='tr_sessionGetAltSpeed_KBps',
setter='tr_sessionSetAltSpeed_KBps',
closure='&tr_down',
closure_cast='*(tr_direction*)',
docstring="Get/set the download alternate speed limit")
cls.add_instance_attribute(
'alt_speed_begin',
'int',
is_pure_c=True,
getter='tr_sessionGetAltSpeedBegin',
setter='tr_sessionSetAltSpeedBegin',
docstring=
"Get/set the time (in minutes since midnight) to begin the alt speed")
cls.add_instance_attribute(
'alt_speed_end',
'int',
is_pure_c=True,
getter='tr_sessionGetAltSpeedEnd',
setter='tr_sessionSetAltSpeedEnd',
docstring=
"Get/set the time (in minutes since midnight) to end the alt speed")
cls.add_instance_attribute(
'alt_speed_day',
'tr_sched_day',
is_pure_c=True,
getter='tr_sessionGetAltSpeedDay',
setter='tr_sessionSetAltSpeedDay',
docstring="Get/set the alt speed transmission.scheduled_days")
cls.add_instance_attribute(
'blocklist_enabled',
'bool',
is_pure_c=True,
getter='tr_blocklistIsEnabled',
setter='tr_blocklistSetEnabled',
docstring="Get/set whether or not to use the peer blocklist")
cls.add_instance_attribute('blocklist_exists',
'bool',
is_const=True,
is_pure_c=True,
getter='tr_blocklistExists',
docstring="Check if the blocklist exists")
cls.add_instance_attribute(
'blocklist_rule_count',
'int',
is_const=True,
is_pure_c=True,
getter='tr_blocklistGetRuleCount',
docstring="Get/set the number of rules in the blocklist")
cls.add_instance_attribute('blocklist_URL',
'char const *',
is_pure_c=True,
getter='tr_blocklistGetURL',
setter='tr_blocklistSetURL',
docstring="Get/set the blocklist URL")
cls.add_instance_attribute('cache_limit',
'int',
is_pure_c=True,
getter='tr_sessionGetCacheLimit_MB',
setter='tr_sessionSetCacheLimit_MB',
docstring="Get/set the cache limit in MB")
cls.add_instance_attribute(
'config_directory',
'char const *',
is_const=True,
is_pure_c=True,
getter='tr_sessionGetConfigDir',
docstring="Get the directory used for configuration files")
root_module.header.writeln(
"tr_session_stats *_wrap_tr_sessionGetCumulativeStats(const tr_session * session);"
)
root_module.body.writeln(
"tr_session_stats *_wrap_tr_sessionGetCumulativeStats(const tr_session * session)\n"
"{\n"
" tr_session_stats *stats = tr_new0(tr_session_stats, 1);\n"
" tr_sessionGetCumulativeStats(session, stats);\n"
" return stats;\n"
"}")
cls.add_instance_attribute(
'cumulative_stats',
ReturnValue.new("tr_session_stats *", caller_owns_return=True),
is_pure_c=True,
is_const=True,
getter='_wrap_tr_sessionGetCumulativeStats',
docstring="Get the total (cumulative) session stats")
cls.add_instance_attribute('delete_source',
'bool',
is_pure_c=True,
getter='tr_sessionGetDeleteSource',
setter='tr_sessionSetDeleteSource',
docstring="")
cls.add_instance_attribute('download_directory',
'char const *',
is_pure_c=True,
getter='tr_sessionGetDownloadDir',
setter='tr_sessionSetDownloadDir',
docstring="Get/set the download directory")
cls.add_instance_attribute(
'download_directory_free_space',
'int64_t',
is_const=True,
is_pure_c=True,
getter='tr_sessionGetDownloadDirFreeSpace',
docstring="Get the download directory free space")
cls.add_instance_attribute(
'encryption_mode',
'tr_encryption_mode',
is_pure_c=True,
getter='tr_sessionGetEncryption',
setter='tr_sessionSetEncryption',
docstring="Get/set the session transmission.encryption_mode")
cls.add_instance_attribute(
'idle_limit',
'uint16_t',
is_pure_c=True,
getter='tr_sessionGetIdleLimit',
setter='tr_sessionSetIdleLimit',
docstring="Get/set the torrent idle limit in minutes")
cls.add_instance_attribute(
'incomplete_directory',
'char const *',
is_pure_c=True,
getter='tr_sessionGetIncompleteDir',
setter='tr_sessionSetIncompleteDir',
docstring="Get/set the directory for incomplete torrents")
cls.add_instance_attribute('paused',
'bool',
is_pure_c=True,
getter='tr_sessionGetPaused',
setter='tr_sessionSetPaused',
docstring="Pause/unpause the session")
cls.add_instance_attribute('peer_limit',
'uint16_t',
is_pure_c=True,
getter='tr_sessionGetPeerLimit',
setter='tr_sessionSetPeerLimit',
docstring="Get/set the peer limit per session")
cls.add_instance_attribute('peer_limit_per_torrent',
'uint16_t',
is_pure_c=True,
getter='tr_sessionGetPeerLimitPerTorrent',
setter='tr_sessionSetPeerLimitPerTorrent',
docstring="Get/set the peer limit per torrent")
cls.add_instance_attribute('peer_port',
'tr_port',
is_pure_c=True,
getter='tr_sessionGetPeerPort',
setter='tr_sessionSetPeerPort',
docstring="Get/set the peer port")
cls.add_instance_attribute(
'peer_port_random_on_start',
'bool',
is_pure_c=True,
getter='tr_sessionGetPeerPortRandomOnStart',
setter='tr_sessionSetPeerPortRandomOnStart',
docstring="Get/set whether or not to use a random peer port on start")
cls.add_instance_attribute(
'port_forwarding',
'tr_port_forwarding',
is_const=True,
is_pure_c=True,
getter='tr_sessionGetPortForwarding',
docstring="Get the session transmission.port_forwarding value")
cls.add_instance_attribute(
'queue_enabled_up',
'bool',
is_pure_c=True,
getter='tr_sessionGetQueueEnabled',
setter='tr_sessionSetQueueEnabled',
closure='&tr_up',
closure_cast='*(tr_direction*)',
docstring="Get/set whether or not to limit how many torrents can upload"
)
cls.add_instance_attribute(
'queue_enabled_down',
'bool',
is_pure_c=True,
getter='tr_sessionGetQueueEnabled',
setter='tr_sessionSetQueueEnabled',
closure='&tr_down',
closure_cast='*(tr_direction*)',
docstring=
"Get/set whether or not to limit how many torrents can download")
cls.add_instance_attribute(
'queue_size_up',
'int',
is_pure_c=True,
getter='tr_sessionGetQueueSize',
setter='tr_sessionSetQueueSize',
closure='&tr_up',
closure_cast='*(tr_direction*)',
docstring="Get/set the number of torrents allowed to upload")
cls.add_instance_attribute(
'queue_size_down',
'int',
is_pure_c=True,
getter='tr_sessionGetQueueSize',
setter='tr_sessionSetQueueSize',
closure='&tr_down',
closure_cast='*(tr_direction*)',
docstring="Get/set the number of torrents allowed to download")
cls.add_instance_attribute(
'queue_stalled_minutes',
'int',
is_pure_c=True,
getter='tr_sessionGetQueueStalledMinutes',
setter='tr_sessionSetQueueStalledMinutes',
docstring=
"Set whether or not to count torrents idle for over N minutes as `stalled\'"
)
cls.add_instance_attribute('queue_stalled_enabled',
'bool',
is_pure_c=True,
getter='tr_sessionGetQueueStalledEnabled',
setter='tr_sessionSetQueueStalledEnabled')
cls.add_instance_attribute('RPC_bind_address',
'char const *',
is_const=True,
is_pure_c=True,
getter='tr_sessionGetRPCBindAddress',
docstring="Get/set RPC bind address")
cls.add_instance_attribute('RPC_password',
'char const *',
is_pure_c=True,
getter='tr_sessionGetRPCPassword',
setter='tr_sessionSetRPCPassword',
docstring="Get/set RPC password")
cls.add_instance_attribute('RPC_port',
'tr_port',
is_pure_c=True,
getter='tr_sessionGetRPCPort',
setter='tr_sessionSetRPCPort',
docstring="Get/set RPC port")
cls.add_instance_attribute('RPC_url',
'char const *',
is_pure_c=True,
getter='tr_sessionGetRPCUrl',
setter='tr_sessionSetRPCUrl',
docstring="Get/set RPC URL")
cls.add_instance_attribute('RPC_username',
'char const *',
is_pure_c=True,
getter='tr_sessionGetRPCUsername',
setter='tr_sessionSetRPCUsername',
docstring="Get/set RPC username")
cls.add_instance_attribute(
'RPC_whitelist',
'char const *',
is_pure_c=True,
getter='tr_sessionGetRPCWhitelist',
setter='tr_sessionSetRPCWhitelist',
docstring="Get/set RPC Access Control List filename")
cls.add_instance_attribute(
'RPC_whitelist_enabled',
'bool',
is_pure_c=True,
getter='tr_sessionGetRPCWhitelistEnabled',
setter='tr_sessionSetRPCWhitelistEnabled',
docstring=
"Get/set if session uses the RPC whitelist for allowing/denying RPC requests"
)
cls.add_instance_attribute('ratio_limit',
'double',
is_pure_c=True,
getter='tr_sessionGetRatioLimit',
setter='tr_sessionSetRatioLimit',
docstring="Get/set the session ratio limit")
cls.add_instance_attribute(
'raw_speed_up',
'double',
is_pure_c=True,
is_const=True,
getter='tr_sessionGetRawSpeed_KBps',
closure='&tr_up',
closure_cast='*(tr_direction*)',
docstring="Get the raw upload speed limit in KBps")
cls.add_instance_attribute(
'raw_speed_down',
'double',
is_pure_c=True,
is_const=True,
getter='tr_sessionGetRawSpeed_KBps',
closure='&tr_up',
closure_cast='*(tr_direction*)',
docstring="Get the raw download speed limit in KBps")
cls.add_instance_attribute(
'speed_limit_up',
'int',
is_pure_c=True,
getter='tr_sessionGetSpeedLimit_KBps',
setter='tr_sessionSetSpeedLimit_KBps',
closure='&tr_up',
closure_cast='*(tr_direction*)',
docstring="Get/set the upload speed limit in KBps")
cls.add_instance_attribute(
'speed_limit_down',
'int',
is_pure_c=True,
getter='tr_sessionGetSpeedLimit_KBps',
setter='tr_sessionSetSpeedLimit_KBps',
closure='&tr_down',
closure_cast='*(tr_direction*)',
docstring="Get/set the download speed limit in KBps")
root_module.header.writeln(
"tr_session_stats *_wrap_tr_sessionGetStats(const tr_session * session);"
)
root_module.body.writeln(
"tr_session_stats *_wrap_tr_sessionGetStats(const tr_session * session)\n"
"{\n"
" tr_session_stats *stats = tr_new0(tr_session_stats, 1);\n"
" tr_sessionGetStats(session, stats);\n"
" return stats;\n"
"}")
cls.add_instance_attribute('stats',
ReturnValue.new("tr_session_stats *",
caller_owns_return=True),
is_const=True,
is_pure_c=True,
getter='_wrap_tr_sessionGetStats',
docstring="Get session stats")
cls.add_instance_attribute(
'torrent_done_script',
'char const *',
is_pure_c=True,
getter='tr_sessionGetTorrentDoneScript',
setter='tr_sessionSetTorrentDoneScript',
docstring=
"Get/set filename of script to be called on torrent completion")
cls.add_instance_attribute('DHT_enabled',
'bool',
is_pure_c=True,
getter='tr_sessionIsDHTEnabled',
setter='tr_sessionSetDHTEnabled',
docstring="Check/set if session uses DHT")
cls.add_instance_attribute(
'idle_limited_enabled',
'bool',
is_pure_c=True,
getter='tr_sessionIsIdleLimited',
setter='tr_sessionSetIdleLimited',
docstring=
"Check/set if session suspends torrent if idle limit is exceded")
cls.add_instance_attribute(
'incomplete_directory_enabled',
'bool',
is_pure_c=True,
getter='tr_sessionIsIncompleteDirEnabled',
setter='tr_sessionSetIncompleteDirEnabled',
docstring=
"Check/set if session uses incomplete directory until download is complete"
)
cls.add_instance_attribute(
'incomplete_file_naming_enabled',
'bool',
is_pure_c=True,
getter='tr_sessionIsIncompleteFileNamingEnabled',
setter='tr_sessionSetIncompleteFileNamingEnabled',
docstring=
"Check/set if session appends `.part\' to files until download is complete"
)
cls.add_instance_attribute('LPD_enabled',
'bool',
is_pure_c=True,
getter='tr_sessionIsLPDEnabled',
setter='tr_sessionSetLPDEnabled',
docstring="Check/set if session uses LPD")
cls.add_instance_attribute('pex_enabled',
'bool',
is_pure_c=True,
getter='tr_sessionIsPexEnabled',
setter='tr_sessionSetPexEnabled',
docstring="Check/set if session uses Pex")
cls.add_instance_attribute(
'port_forwarding_enabled',
'bool',
is_pure_c=True,
getter='tr_sessionIsPortForwardingEnabled',
setter='tr_sessionSetPortForwardingEnabled',
docstring="Check/set if session uses port forwarding")
cls.add_instance_attribute(
'RPC_enabled',
'bool',
is_pure_c=True,
getter='tr_sessionIsRPCEnabled',
setter='tr_sessionSetRPCEnabled',
docstring="Check/set if session uses RPC server")
cls.add_instance_attribute(
'RPC_password_enabled',
'bool',
is_pure_c=True,
getter='tr_sessionIsRPCPasswordEnabled',
setter='tr_sessionSetRPCPasswordEnabled',
docstring="Check/set if RPC server requires password")
cls.add_instance_attribute(
'ratio_limit_enabled',
'bool',
is_pure_c=True,
getter='tr_sessionIsRatioLimited',
setter='tr_sessionSetRatioLimited',
docstring="Check/set if session is ratio limited")
cls.add_instance_attribute(
'speed_limit_enabled_up',
'bool',
is_pure_c=True,
getter='tr_sessionIsSpeedLimited',
setter='tr_sessionLimitSpeed',
closure='&tr_up',
closure_cast='*(tr_direction*)',
docstring="Check/set if session limits upload speed")
cls.add_instance_attribute(
'speed_limit_enabled_down',
'bool',
is_pure_c=True,
getter='tr_sessionIsSpeedLimited',
setter='tr_sessionLimitSpeed',
closure='&tr_down',
closure_cast='*(tr_direction*)',
docstring="Check/set if session limits download speed")
cls.add_instance_attribute(
'torrent_done_script_enabled',
'bool',
is_pure_c=True,
getter='tr_sessionIsTorrentDoneScriptEnabled',
setter='tr_sessionSetTorrentDoneScriptEnabled',
docstring="Check/set if session uses calls Session.torrent_done_script"
)
cls.add_instance_attribute('UTP_enabled',
'bool',
is_pure_c=True,
getter='tr_sessionIsUTPEnabled',
setter='tr_sessionSetUTPEnabled',
docstring="Check/set if session uses UTP")
cls.add_instance_attribute('alt_speed_enabled',
'bool',
is_pure_c=True,
getter='tr_sessionUsesAltSpeed',
setter='tr_sessionUseAltSpeed',
docstring="Check/set if session uses alt speed")
cls.add_instance_attribute(
'alt_speed_time_enabled',
'bool',
is_pure_c=True,
getter='tr_sessionUsesAltSpeedTime',
setter='tr_sessionUseAltSpeedTime',
docstring="Check/set if session uses alt speed time")
cls.add_function_as_method(
'tr_sessionReloadBlocklists',
'void', [param('tr_session *', 'session', transfer_ownership=False)],
custom_name='blocklists_reload',
docstring="Reload blocklists")
cls.add_function_as_method(
'tr_blocklistSetContent',
'int', [
param('tr_session *', 'session', transfer_ownership=False),
param('char const *', 'filename', default_value='NULL')
],
custom_name='blocklist_set',
docstring="Set blocklist content\\n\\n"
"Args:\\n"
" filename (str): blocklist filename or nothing to clear\\n"
"Returns:\\n"
" number of entries added")
cls.add_function_as_method(
'tr_sessionClearStats',
'void', [param('tr_session *', 'session', transfer_ownership=False)],
custom_name='stats_clear',
docstring="Clear session stats")
cls.add_function_as_method(
'tr_sessionSetPeerPortRandom',
'tr_port',
[param('tr_session *', 'session', transfer_ownership=False)],
custom_name='peer_port_set_random',
docstring="Set incoming peer port to a random port\\n\\n"
"Returns:\\n"
" the port number")
root_module.header.writeln(
"""void _wrap_alt_speed_callback(tr_session *session, bool active, bool userDriven, void *data);"""
)
root_module.body.writeln("""
void _wrap_alt_speed_callback(tr_session *session, bool active, bool userDriven, void *data)
{
PyObject *callback = (PyObject*) data;
PyTr_session *py_session = PyObject_New(PyTr_session, &PyTr_session_Type);
py_session->obj = session;
py_session->flags = PYBINDGEN_WRAPPER_FLAG_OBJECT_NOT_OWNED;
PyObject_CallFunction(callback, (char*)"Obb", (PyObject*)py_session, active, userDriven);
Py_DECREF(py_session);
}
""")
cls.add_function_as_method(
'tr_sessionSetAltSpeedFunc',
'void', [
param('tr_session *', 'session', transfer_ownership=False),
param('tr_altSpeedFunc *',
'callback',
callback_func="_wrap_alt_speed_callback")
],
custom_name='alt_speed_function_set',
docstring=
"Function to be called when alternate speed is enabled/disabled\\n\\n"
"Args:\\n"
" callback (function): callable object or function\\n"
" pass `None\' to clear existing callback")
root_module.header.writeln(
"""tr_rpc_callback_status _wrap_rpc_callback(tr_session *session, tr_rpc_callback_type type, struct tr_torrent *tor, void *data);"""
)
root_module.body.writeln("""
tr_rpc_callback_status _wrap_rpc_callback(tr_session *session, tr_rpc_callback_type type,
struct tr_torrent *tor, void *data)
{
PyObject *py_torrent, *py_retval;
PyObject *callback = (PyObject*) data;
int retval = 0;
PyTr_session *py_session = PyObject_New(PyTr_session, &PyTr_session_Type);
py_session->obj = session;
py_session->flags = PYBINDGEN_WRAPPER_FLAG_OBJECT_NOT_OWNED;
if (tor) {
PyTr_torrent *tmp = PyObject_New(PyTr_torrent, &PyTr_torrent_Type);
tmp->obj = tor;
tmp->flags = PYBINDGEN_WRAPPER_FLAG_OBJECT_NOT_OWNED;
py_torrent = (PyObject *)tmp;
} else {
Py_INCREF(Py_None);
py_torrent = Py_None;
}
py_retval = PyObject_CallFunction(callback, (char*)"OiO", (PyObject*)py_session, type, py_torrent);
if (py_retval && PyLong_Check(py_retval))
retval = PyLong_AsLong(py_retval);
Py_DECREF(py_session);
Py_DECREF(py_torrent);
Py_DECREF(py_retval);
return retval == (int)TR_RPC_NOREMOVE ? TR_RPC_NOREMOVE : TR_RPC_OK;
}
""")
cls.add_function_as_method(
'tr_sessionSetRPCCallback',
'void', [
param('tr_session *', 'session', transfer_ownership=False),
param(
'tr_rpc_func', 'callback', callback_func="_wrap_rpc_callback")
],
custom_name='RPC_callback',
docstring=
"Function to be called whenever something is changed via RPC\\n\\n"
"Args:\\n"
" callback (function): callable object or function\\n"
" pass `None\' to clear existing callback")
cls.add_function_as_method(
'tr_sessionGetSettings',
'void', [
param('tr_session *', 'session', transfer_ownership=False),
BencOutParam('BencDict *', 'dict')
],
custom_name='settings',
docstring="Get a `BencDict\' of session settings")
cls.add_function_as_method(
'tr_sessionLoadTorrents',
retval("tr_torrent **",
array_length='count',
reference_existing_object=True),
[
param('tr_session *', 'session', transfer_ownership=False),
param('tr_ctor *', 'torrent_constructor',
transfer_ownership=False),
CountParam('int', 'count')
],
custom_name='load_torrents',
docstring="Load all the torrents in the torrent directory")
root_module.header.writeln(
"#define _wrap_tr_torrentNew(s, ctor, err) tr_torrentNew(ctor, err)")
cls.add_function_as_method(
"_wrap_tr_torrentNew",
ReturnValue.new("tr_torrent *", reference_existing_object=True), [
param('tr_session *', 'session', transfer_ownership=False),
param('tr_ctor *', 'ctor', transfer_ownership=False),
TorrentErrorParam('int', 'setmeError')
],
custom_name='torrent_new')
root_module.header.writeln(
"#define _wrap_tr_torrentFree(s, tor) tr_torrentFree(tor)")
cls.add_function_as_method(
'_wrap_tr_torrentFree',
'void', [
param('tr_session *', 'session', transfer_ownership=False),
param('tr_torrent *', 'torrent', transfer_ownership=True)
],
unblock_threads=True,
custom_name='torrent_free')
root_module.header.writeln(
"#define _wrap_tr_torrentRemove(s, tor, rem, fn) tr_torrentRemove(tor, rem, fn)"
)
cls.add_function_as_method(
'_wrap_tr_torrentRemove',
'void', [
param('tr_session *', 'session', transfer_ownership=False),
param('tr_torrent *', 'torrent', transfer_ownership=True),
param('bool', 'remove_local_data', default_value='0'),
param('NULL', 'removeFunc')
],
custom_name='torrent_remove')
cls.add_custom_method_wrapper('torrents',
'_wrap_tr_torrentList',
flags=["METH_NOARGS"],
wrapper_body="""
static PyObject* _wrap_tr_torrentList(PyTr_session *self, PyObject **return_exception)
{
tr_torrent *torrent = NULL;
PyObject *py_list = PyList_New(0);
while ((torrent = tr_torrentNext(self->obj, torrent)) != NULL) {
PyTr_torrent *elem = PyObject_New(PyTr_torrent, &PyTr_torrent_Type);
elem->obj = torrent;
elem->flags = PYBINDGEN_WRAPPER_FLAG_OBJECT_NOT_OWNED;
PyList_Append(py_list, (PyObject*)elem);
}
return py_list;
}
""")
cls.add_function_as_method(
'tr_sessionSaveSettings',
'void', [
param('tr_session *', 'session', transfer_ownership=False),
param('char const *', 'directory'),
param('BencDict const *', 'settings', transfer_ownership=False)
],
custom_name='settings_save',
docstring="Save `settings\' to `directory\'")
cls.add_function_as_method(
'tr_sessionSet',
'void', [
param('tr_session *', 'session', transfer_ownership=False),
param('BencDict *', 'settings', transfer_ownership=False)
],
custom_name='update',
docstring="Update session settings from `BencDict\'")
return
def register_Tr_info_methods(root_module, cls):
cls.add_instance_attribute('comment', 'char *', is_const=True)
cls.add_instance_attribute('creator', 'char *', is_const=True)
cls.add_instance_attribute('dateCreated',
'time_t',
is_const=True,
custom_name='date_created')
cls.add_instance_attribute('fileCount',
'tr_file_index_t',
is_const=True,
custom_name='file_count')
cls.add_instance_attribute('files',
ReturnValue.new(
'tr_file **',
array_length="self->obj->fileCount",
caller_owns_return=False),
is_const=True)
cls.add_instance_attribute('hash',
ReturnValue.new('uint8_t *',
is_const=True,
array_length=SHA_DIGEST_LENGTH),
is_const=True)
cls.add_instance_attribute('hashString',
'char *',
is_const=True,
custom_name='hash_string')
cls.add_instance_attribute('isMultifile',
'bool',
is_const=True,
custom_name='multifile')
cls.add_instance_attribute('isPrivate',
'bool',
is_const=True,
custom_name='private')
cls.add_instance_attribute('name', 'char *', is_const=True)
cls.add_instance_attribute('pieceCount',
'tr_piece_index_t',
is_const=True,
custom_name='piece_count')
cls.add_instance_attribute('pieceSize',
'uint32_t',
is_const=True,
custom_name='piece_size')
cls.add_instance_attribute('pieces',
ReturnValue.new(
'tr_piece **',
array_length="self->obj->pieceCount",
caller_owns_return=False),
is_const=True)
cls.add_instance_attribute('torrent', 'char *', is_const=True)
cls.add_instance_attribute('totalSize',
'uint64_t',
is_const=True,
custom_name='total_size')
cls.add_instance_attribute('trackerCount',
'int',
is_const=True,
custom_name='tracker_count')
cls.add_instance_attribute('trackers',
ReturnValue.new(
'tr_tracker_info **',
array_length="self->obj->trackerCount",
caller_owns_return=False),
is_const=True)
cls.add_instance_attribute('webseedCount',
'int',
is_const=True,
custom_name='webseed_count')
cls.add_instance_attribute('webseeds',
ReturnValue.new(
'char **',
array_length="self->obj->webseedCount"),
is_const=True)
return
def register_Tr_torrent_methods(root_module, cls):
cls.add_instance_attribute('can_manual_update', 'bool',
is_const=True,
is_pure_c=True,
getter='tr_torrentCanManualUpdate',
setter=None)
cls.add_instance_attribute('bytes_left_to_allocate', 'uint64_t',
is_const=True,
is_pure_c=True,
getter='tr_torrentGetBytesLeftToAllocate',
setter=None)
cls.add_instance_attribute('current_directory', 'char const *',
is_const=True,
is_pure_c=True,
getter='tr_torrentGetCurrentDir',
setter=None)
cls.add_instance_attribute('download_directory', 'char const *',
is_const=True,
is_pure_c=True,
getter='tr_torrentGetDownloadDir')
cls.add_instance_attribute('file_priorities',
AllocedReturn('tr_priority_t *',
array_length="tr_torrentInfo(self->obj)->fileCount"),
is_const=True,
is_pure_c=True,
getter='tr_torrentGetFilePriorities')
cls.add_instance_attribute('idle_limit', 'uint16_t',
is_pure_c=True,
getter='tr_torrentGetIdleLimit',
setter='tr_torrentSetIdleLimit')
cls.add_instance_attribute('idle_mode', IdleLimitReturn('tr_idlelimit'),
is_pure_c=True,
getter='tr_torrentGetIdleMode',
setter='tr_torrentSetIdleMode')
cls.add_instance_attribute('magnet_link', NewCharReturn('char *'),
is_const=True,
is_pure_c=True,
getter='tr_torrentGetMagnetLink',
setter=None)
cls.add_instance_attribute('peer_limit', 'uint16_t',
is_pure_c=True,
getter='tr_torrentGetPeerLimit',
setter='tr_torrentSetPeerLimit')
cls.add_instance_attribute('priority', 'tr_priority_t',
is_pure_c=True,
getter='tr_torrentGetPriority',
setter='tr_torrentSetPriority')
cls.add_instance_attribute('queue_position', 'int',
is_pure_c=True,
getter='tr_torrentGetQueuePosition',
setter='tr_torrentSetQueuePosition')
cls.add_instance_attribute('ratio_limit', 'double',
is_pure_c=True,
getter='tr_torrentGetRatioLimit',
setter='tr_torrentSetRatioLimit')
cls.add_instance_attribute('ratio_mode', RatioModeReturn('tr_ratiolimit'),
is_pure_c=True,
getter='tr_torrentGetRatioMode',
setter='tr_torrentSetRatioMode')
cls.add_instance_attribute('seed_idle', 'bool',
is_const=True,
is_pure_c=True,
getter='tr_torrentGetSeedIdle',
closure_cast='(uint16_t *)')
root_module.header.writeln("uint16_t _wrap_tr_torrentGetSeedIdleMinutes(const tr_torrent * tor);")
root_module.body.writeln("uint16_t _wrap_tr_torrentGetSeedIdleMinutes(const tr_torrent * tor)\n"
"{\n"
" uint16_t idleMinutes;\n"
" return tr_torrentGetSeedIdle(tor, &idleMinutes) ? idleMinutes : 0;\n"
"}")
cls.add_instance_attribute('seed_idle_minutes', 'uint16_t',
is_const=True,
is_pure_c=True,
getter='_wrap_tr_torrentGetSeedIdleMinutes')
root_module.header.writeln("double _wrap_tr_torrentGetSeedRatio(const tr_torrent * tor);")
root_module.body.writeln("double _wrap_tr_torrentGetSeedRatio(const tr_torrent * tor)\n"
"{\n"
" double ratio;\n"
" return tr_torrentGetSeedRatio(tor, &ratio) ? ratio : 0;\n"
"}")
cls.add_instance_attribute('seed_ratio', 'double',
is_const=True,
is_pure_c=True,
getter='_wrap_tr_torrentGetSeedRatio')
cls.add_instance_attribute('speed_limit_up', 'uint8_t',
is_pure_c=True,
getter='tr_torrentGetSpeedLimit_KBps',
setter='tr_torrentSetSpeedLimit_KBps',
closure='&tr_up', closure_cast='*(tr_direction*)')
cls.add_instance_attribute('speed_limit_down', 'uint8_t',
is_pure_c=True,
getter='tr_torrentGetSpeedLimit_KBps',
setter='tr_torrentSetSpeedLimit_KBps',
closure='&tr_down', closure_cast='*(tr_direction*)')
cls.add_instance_attribute('use_speed_limit_up', 'bool',
is_pure_c=True,
getter='tr_torrentUsesSpeedLimit',
setter='tr_torrentUseSpeedLimit',
closure='&tr_up', closure_cast='*(tr_direction*)')
cls.add_instance_attribute('use_speed_limit_down', 'bool',
is_pure_c=True,
getter='tr_torrentUsesSpeedLimit',
setter='tr_torrentUseSpeedLimit',
closure='&tr_down', closure_cast='*(tr_direction*)')
cls.add_instance_attribute('has_metadata', 'bool',
is_const=True,
is_pure_c=True,
getter='tr_torrentHasMetadata',
setter=None)
cls.add_instance_attribute('id', 'int',
is_const=True,
is_pure_c=True,
getter='tr_torrentId',
setter=None)
cls.add_instance_attribute('info',
ReturnValue.new("tr_info *", return_internal_reference=True, is_const=True),
is_const=True,
is_pure_c=True,
getter='tr_torrentInfo')
cls.add_instance_attribute('name', 'char const *',
is_const=True,
is_pure_c=True,
getter='tr_torrentName')
cls.add_instance_attribute('use_session_limits', 'bool',
is_pure_c=True,
getter='tr_torrentUsesSessionLimits',
setter='tr_torrentUseSessionLimits')
cls.add_instance_attribute('web_speeds',
AllocedReturn('double *',
array_length="tr_torrentInfo(self->obj)->webseedCount"),
is_pure_c=True,
is_const=True,
getter='tr_torrentWebSpeeds_KBps',
setter=None)
cls.add_function_as_method('tr_torrentStart',
'void',
[param('tr_torrent *', 'torrent', transfer_ownership=False)],
custom_name='start')
cls.add_function_as_method('tr_torrentStartNow',
'void',
[param('tr_torrent *', 'torrent', transfer_ownership=False)],
custom_name='start_now')
cls.add_function_as_method('tr_torrentStop',
'void',
[param('tr_torrent *', 'torrent', transfer_ownership=False)],
custom_name='stop')
cls.add_function_as_method('tr_torrentStat',
'tr_stat const *',
[param('tr_torrent *', 'torrent', transfer_ownership=False)],
custom_name='stats')
cls.add_function_as_method('tr_torrentStatCached',
'tr_stat const *',
[param('tr_torrent *', 'torrent', transfer_ownership=False)],
custom_name='stats_cached')
cls.add_function_as_method('tr_torrentVerify',
'void',
[param('tr_torrent *', 'torrent', transfer_ownership=False)],
custom_name='verify')
cls.add_function_as_method('tr_torrentAmountFinished',
'void',
[param('tr_torrent *', 'torrent', transfer_ownership=False),
FloatCountParam('int', 'size')],
custom_name='amount_finished')
cls.add_function_as_method('tr_torrentAvailability',
'void',
[param('tr_torrent *', 'torrent', transfer_ownership=False),
BoolCountParam('int', 'size')],
custom_name='availability')
cls.add_function_as_method('tr_torrentFiles',
AllocedListReturn('tr_file_stat *', array_length='count'),
[param('tr_torrent *', 'torrent', transfer_ownership=False),
CountParam('tr_file_index_t', 'count')],
custom_name='files')
cls.add_function_as_method('tr_torrentFindFile',
'char *',
[param('tr_torrent *', 'torrent', transfer_ownership=False),
param('tr_file_index_t', 'file_number')],
custom_name='find_file')
cls.add_function_as_method('tr_torrentPeers',
AllocedListReturn("tr_peer_stat *", array_length='count'),
[param('tr_torrent *', 'torrent', transfer_ownership=False),
CountParam('int', 'count')],
custom_name='peers')
cls.add_function_as_method('tr_torrentSetAnnounceList',
'bool',
[param('tr_torrent *', 'torrent', transfer_ownership=False),
TrackerInfoListParam('tr_tracker_info', 'trackers')],
custom_name='set_announce_list')
cls.add_function_as_method('tr_torrentSetFileDLs',
'void',
[param('tr_torrent *', 'torrent', transfer_ownership=False),
param('tr_file_index_t const *', 'files'),
DummyParam('1', 'fileCount'),
param('bool', 'download')],
custom_name='file_set_download')
cls.add_function_as_method('tr_torrentSetFilePriorities',
'void',
[param('tr_torrent *', 'torrent', transfer_ownership=False),
param('tr_file_index_t *', 'index'),
DummyParam('1', 'fileCount'),
param('tr_priority_t', 'priority')],
custom_name='file_set_priority')
cls.add_function_as_method('tr_torrentSetLocation',
'void',
[param('tr_torrent *', 'torrent', transfer_ownership=False),
param('char const *', 'location'),
param('bool', 'move'),
param('NULL', 'progress'),
param('NULL', 'state')],
custom_name='set_location')
cls.add_function_as_method('tr_torrentTrackers',
AllocedListReturn('tr_tracker_stat *', array_length='count'),
[param('tr_torrent *', 'torrent', transfer_ownership=False),
CountParam('int', 'count')],
custom_name='trackers')
root_module.header.writeln("""void _wrap_completeness_callback(tr_torrent *torrent, tr_completeness completeness, bool wasRunning, void *data);""")
root_module.body.writeln("""
void _wrap_completeness_callback(tr_torrent *torrent, tr_completeness completeness, bool wasRunning, void *data)
{
PyObject *callback = (PyObject*) data;
PyGILState_STATE __py_gil_state;
__py_gil_state = (PyEval_ThreadsInitialized() ? PyGILState_Ensure() : (PyGILState_STATE) 0);
PyTr_torrent *py_torrent = PyObject_New(PyTr_torrent, &PyTr_torrent_Type);
py_torrent->obj = torrent;
py_torrent->flags = PYBINDGEN_WRAPPER_FLAG_OBJECT_NOT_OWNED;
PyObject_CallFunction(callback, (char*)"Oib", (PyObject*)py_torrent, completeness, wasRunning);
Py_DECREF(py_torrent);
if (PyEval_ThreadsInitialized())
PyGILState_Release(__py_gil_state);
}
""")
cls.add_function_as_method('tr_torrentSetCompletenessCallback',
'void',
[param('tr_torrent *', 'torrent', transfer_ownership=False),
param('tr_torrent_completeness_func *', 'func',
callback_func="_wrap_completeness_callback")],
custom_name='completeness_callback_set')
root_module.header.writeln("""void _wrap_no_call_args_callback(tr_torrent *torrent, void *data);""")
root_module.body.writeln("""
void _wrap_no_call_args_callback(tr_torrent *torrent, void *data)
{
PyObject *callback = (PyObject*) data;
PyTr_torrent *py_torrent = PyObject_New(PyTr_torrent, &PyTr_torrent_Type);
py_torrent->obj = torrent;
py_torrent->flags = PYBINDGEN_WRAPPER_FLAG_OBJECT_NOT_OWNED;
PyObject_CallFunction(callback, (char*)"O", (PyObject*)py_torrent);
Py_DECREF(py_torrent);
}
""")
cls.add_function_as_method('tr_torrentSetIdleLimitHitCallback',
'void',
[param('tr_torrent *', 'torrent', transfer_ownership=False),
param('tr_torrent_idle_limit_hit_func *', 'func',
callback_func="_wrap_no_call_args_callback")],
custom_name='idle_limit_hit_callback')
cls.add_function_as_method('tr_torrentSetMetadataCallback',
'void',
[param('tr_torrent *', 'torrent', transfer_ownership=False),
param('tr_torrent_metadata_func *', 'func',
callback_func="_wrap_no_call_args_callback")],
custom_name='metadata_callback')
root_module.header.writeln("""typedef void (tr_torrent_queue_start_func)(tr_torrent *torrent, void *data);""")
cls.add_function_as_method('tr_torrentSetQueueStartCallback',
'void',
[param('tr_torrent *', 'torrent', transfer_ownership=False),
param('tr_torrent_queue_start_func *', 'func',
callback_func="_wrap_no_call_args_callback")],
custom_name='queue_start_callback')
cls.add_function_as_method('tr_torrentSetRatioLimitHitCallback',
'void',
[param('tr_torrent *', 'torrent', transfer_ownership=False),
param('tr_torrent_ratio_limit_hit_func *', 'func',
callback_func="_wrap_no_call_args_callback")],
custom_name='ratio_limit_hit_callback')
return
def customize_module(module):
pybindgen.settings.wrapper_registry = pybindgen.settings.StdMapWrapperRegistry
wrapper_body = '''
static PyObject *
_wrap_foofunction_that_takes_foo_from_string(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args,
PyObject *kwargs, PyObject **return_exception)
{
PyObject *py_retval;
char *datum;
const char *keywords[] = {"foo", NULL};
if (!PyArg_ParseTupleAndKeywords(args, kwargs, (char *) "s", (char **) keywords, &datum)) {
{
PyObject *exc_type, *traceback;
PyErr_Fetch(&exc_type, return_exception, &traceback);
Py_XDECREF(exc_type);
Py_XDECREF(traceback);
}
return NULL;
}
function_that_takes_foo(Foo(datum));
Py_INCREF(Py_None);
py_retval = Py_None;
return py_retval;
}
'''
module.add_custom_function_wrapper('function_that_takes_foo',
'_wrap_foofunction_that_takes_foo_from_string',
wrapper_body)
## test a custom method wrapper
Bar, = [cls for cls in module.classes if cls.name == 'Bar']
wrapper_body = '''
static PyObject *
_wrap_PyBar_Hooray_lenx(PyBar *PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs,
PyObject **return_exception)
{
PyObject *py_retval;
int x;
const char *keywords[] = {"x", NULL};
if (!PyArg_ParseTupleAndKeywords(args, kwargs, (char *) "i", (char **) keywords, &x)) {
PyObject *exc_type, *traceback;
PyErr_Fetch(&exc_type, return_exception, &traceback);
Py_XDECREF(exc_type);
Py_XDECREF(traceback);
return NULL;
}
std::string retval;
retval = Bar::Hooray();
py_retval = Py_BuildValue((char *) "i", int(retval.size() + x));
return py_retval;
}
'''
Bar.add_custom_method_wrapper("Hooray", "_wrap_PyBar_Hooray_lenx",
wrapper_body,
flags=["METH_VARARGS", "METH_KEYWORDS", "METH_STATIC"])
Foo, = [cls for cls in module.classes if cls.name == 'Foo']
def Foo_instance_creation_function(dummy_cpp_class, code_block, lvalue,
parameters, construct_type_name):
code_block.write_code(
"%s = new %s(%s);" % (lvalue, construct_type_name, parameters))
code_block.write_code("%s->initialize();" % (lvalue,))
Foo.set_instance_creation_function(Foo_instance_creation_function)
VectorLike2, = [cls for cls in module.classes if cls.name == 'VectorLike2']
VectorLike2.add_container_traits(ReturnValue.new('double'), begin_method='Begin', end_method='End', iterator_type='Iterator')
MapLike, = [cls for cls in module.classes if cls.name == 'MapLike']
MapLike.add_container_traits((ReturnValue.new('int'), ReturnValue.new('double')),
begin_method='Begin', end_method='End', iterator_type='Iterator',
is_mapping=True)
# just a compilation test, this won't actually work in runtime
module.add_include('<stdio.h>')
module.add_class(name="FILE", foreign_cpp_namespace="", import_from_module="__builtin__ named file")
module.add_enum("reg_errcode_t", ["REG_NOERROR", "REG_NOMATCH"], import_from_module="__builtin__")
def generate_callback_classes(out, callbacks):
for callback_impl_num, template_parameters in enumerate(callbacks):
sink = MemoryCodeSink()
cls_name = "ns3::Callback< %s >" % ', '.join(template_parameters)
#print >> sys.stderr, "***** trying to register callback: %r" % cls_name
class_name = "PythonCallbackImpl%i" % callback_impl_num
sink.writeln('''
class %s : public ns3::CallbackImpl<%s>
{
public:
PyObject *m_callback;
%s(PyObject *callback)
{
Py_INCREF(callback);
m_callback = callback;
}
virtual ~%s()
{
PyGILState_STATE __py_gil_state;
__py_gil_state = (PyEval_ThreadsInitialized() ? PyGILState_Ensure() : (PyGILState_STATE) 0);
Py_DECREF(m_callback);
m_callback = NULL;
PyGILState_Release(__py_gil_state);
}
virtual bool IsEqual(ns3::Ptr<const ns3::CallbackImplBase> other_base) const
{
const %s *other = dynamic_cast<const %s*> (ns3::PeekPointer (other_base));
if (other != NULL)
return (other->m_callback == m_callback);
else
return false;
}
''' % (class_name, ', '.join(template_parameters), class_name, class_name, class_name, class_name))
sink.indent()
callback_return = template_parameters[0]
return_ctype = ctypeparser.parse_type(callback_return)
if ('const' in return_ctype.remove_modifiers()):
kwargs = {'is_const': True}
else:
kwargs = {}
try:
return_type = ReturnValue.new(str(return_ctype), **kwargs)
except (typehandlers.TypeLookupError, typehandlers.TypeConfigurationError) as ex:
warnings.warn("***** Unable to register callback; Return value '%s' error (used in %s): %r"
% (callback_return, cls_name, ex),
Warning)
continue
arguments = []
ok = True
callback_parameters = [arg for arg in template_parameters[1:] if arg != 'ns3::empty']
for arg_num, arg_type in enumerate(callback_parameters):
arg_name = 'arg%i' % (arg_num+1)
param_ctype = ctypeparser.parse_type(arg_type)
if ('const' in param_ctype.remove_modifiers()):
kwargs = {'is_const': True}
else:
kwargs = {}
try:
arguments.append(Parameter.new(str(param_ctype), arg_name, **kwargs))
except (typehandlers.TypeLookupError, typehandlers.TypeConfigurationError) as ex:
warnings.warn("***** Unable to register callback; parameter '%s %s' error (used in %s): %r"
% (arg_type, arg_name, cls_name, ex),
Warning)
ok = False
if not ok:
continue
wrapper = CallbackImplProxyMethod(return_type, arguments)
wrapper.generate(sink, 'operator()', decl_modifiers=[])
sink.unindent()
sink.writeln('};\n')
sink.flush_to(out)
class PythonCallbackParameter(Parameter):
"Class handlers"
CTYPES = [cls_name]
print("***** registering callback handler: %r" % ctypeparser.normalize_type_string(cls_name), file=sys.stderr)
DIRECTIONS = [Parameter.DIRECTION_IN]
PYTHON_CALLBACK_IMPL_NAME = class_name
TEMPLATE_ARGS = template_parameters
def convert_python_to_c(self, wrapper):
"parses python args to get C++ value"
assert isinstance(wrapper, typehandlers.ForwardWrapperBase)
if self.default_value is None:
py_callback = wrapper.declarations.declare_variable('PyObject*', self.name)
wrapper.parse_params.add_parameter('O', ['&'+py_callback], self.name)
wrapper.before_call.write_error_check(
'!PyCallable_Check(%s)' % py_callback,
'PyErr_SetString(PyExc_TypeError, "parameter \'%s\' must be callbale");' % self.name)
callback_impl = wrapper.declarations.declare_variable(
'ns3::Ptr<%s>' % self.PYTHON_CALLBACK_IMPL_NAME,
'%s_cb_impl' % self.name)
wrapper.before_call.write_code("%s = ns3::Create<%s> (%s);"
% (callback_impl, self.PYTHON_CALLBACK_IMPL_NAME, py_callback))
wrapper.call_params.append(
'ns3::Callback<%s> (%s)' % (', '.join(self.TEMPLATE_ARGS), callback_impl))
else:
py_callback = wrapper.declarations.declare_variable('PyObject*', self.name, 'NULL')
wrapper.parse_params.add_parameter('O', ['&'+py_callback], self.name, optional=True)
value = wrapper.declarations.declare_variable(
'ns3::Callback<%s>' % ', '.join(self.TEMPLATE_ARGS),
self.name+'_value',
self.default_value)
wrapper.before_call.write_code("if (%s) {" % (py_callback,))
wrapper.before_call.indent()
wrapper.before_call.write_error_check(
'!PyCallable_Check(%s)' % py_callback,
'PyErr_SetString(PyExc_TypeError, "parameter \'%s\' must be callbale");' % self.name)
wrapper.before_call.write_code("%s = ns3::Callback<%s> (ns3::Create<%s> (%s));"
% (value, ', '.join(self.TEMPLATE_ARGS),
self.PYTHON_CALLBACK_IMPL_NAME, py_callback))
wrapper.before_call.unindent()
wrapper.before_call.write_code("}") # closes: if (py_callback) {
wrapper.call_params.append(value)
def convert_c_to_python(self, wrapper):
raise typehandlers.NotSupportedError("Reverse wrappers for ns3::Callback<...> types "
"(python using callbacks defined in C++) not implemented.")
def customize_module(module):
pybindgen.settings.wrapper_registry = pybindgen.settings.StdMapWrapperRegistry
wrapper_body = '''
static PyObject *
_wrap_foofunction_that_takes_foo_from_string(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args,
PyObject *kwargs, PyObject **return_exception)
{
PyObject *py_retval;
char *datum;
const char *keywords[] = {"foo", NULL};
if (!PyArg_ParseTupleAndKeywords(args, kwargs, (char *) "s", (char **) keywords, &datum)) {
{
PyObject *exc_type, *traceback;
PyErr_Fetch(&exc_type, return_exception, &traceback);
Py_XDECREF(exc_type);
Py_XDECREF(traceback);
}
return NULL;
}
function_that_takes_foo(Foo(datum));
Py_INCREF(Py_None);
py_retval = Py_None;
return py_retval;
}
'''
module.add_custom_function_wrapper('function_that_takes_foo',
'_wrap_foofunction_that_takes_foo_from_string',
wrapper_body)
## test a custom method wrapper
Bar, = [cls for cls in module.classes if cls.name == 'Bar']
wrapper_body = '''
static PyObject *
_wrap_PyBar_Hooray_lenx(PyBar *PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs,
PyObject **return_exception)
{
PyObject *py_retval;
int x;
const char *keywords[] = {"x", NULL};
if (!PyArg_ParseTupleAndKeywords(args, kwargs, (char *) "i", (char **) keywords, &x)) {
PyObject *exc_type, *traceback;
PyErr_Fetch(&exc_type, return_exception, &traceback);
Py_XDECREF(exc_type);
Py_XDECREF(traceback);
return NULL;
}
std::string retval;
retval = Bar::Hooray();
py_retval = Py_BuildValue((char *) "i", int(retval.size() + x));
return py_retval;
}
'''
Bar.add_custom_method_wrapper("Hooray", "_wrap_PyBar_Hooray_lenx",
wrapper_body,
flags=["METH_VARARGS", "METH_KEYWORDS", "METH_STATIC"])
Foo, = [cls for cls in module.classes if cls.name == 'Foo']
def Foo_instance_creation_function(dummy_cpp_class, code_block, lvalue,
parameters, construct_type_name):
code_block.write_code(
"%s = new %s(%s);" % (lvalue, construct_type_name, parameters))
code_block.write_code("%s->initialize();" % (lvalue,))
Foo.set_instance_creation_function(Foo_instance_creation_function)
VectorLike2, = [cls for cls in module.classes if cls.name == 'VectorLike2']
VectorLike2.add_container_traits(ReturnValue.new('double'), begin_method='Begin', end_method='End', iterator_type='Iterator')
MapLike, = [cls for cls in module.classes if cls.name == 'MapLike']
MapLike.add_container_traits((ReturnValue.new('int'), ReturnValue.new('double')),
begin_method='Begin', end_method='End', iterator_type='Iterator',
is_mapping=True)
def generate_callback_classes(out, callbacks):
for callback_impl_num, template_parameters in enumerate(callbacks):
sink = MemoryCodeSink()
cls_name = "ns3::Callback< %s >" % ', '.join(template_parameters)
#print >> sys.stderr, "***** trying to register callback: %r" % cls_name
class_name = "PythonCallbackImpl%i" % callback_impl_num
sink.writeln('''
class %s : public ns3::CallbackImpl<%s>
{
public:
PyObject *m_callback;
%s(PyObject *callback)
{
Py_INCREF(callback);
m_callback = callback;
}
virtual ~%s()
{
Py_DECREF(m_callback);
m_callback = NULL;
}
virtual bool IsEqual(ns3::Ptr<const ns3::CallbackImplBase> other_base) const
{
const %s *other = dynamic_cast<const %s*> (ns3::PeekPointer (other_base));
if (other != NULL)
return (other->m_callback == m_callback);
else
return false;
}
''' % (class_name, ', '.join(template_parameters), class_name, class_name, class_name, class_name))
sink.indent()
callback_return = template_parameters[0]
return_ctype = ctypeparser.parse_type(callback_return)
if ('const' in return_ctype.remove_modifiers()):
kwargs = {'is_const': True}
else:
kwargs = {}
try:
return_type = ReturnValue.new(str(return_ctype), **kwargs)
except (typehandlers.TypeLookupError, typehandlers.TypeConfigurationError), ex:
warnings.warn("***** Unable to register callback; Return value '%s' error (used in %s): %r"
% (callback_return, cls_name, ex),
Warning)
continue
arguments = []
ok = True
callback_parameters = [arg for arg in template_parameters[1:] if arg != 'ns3::empty']
for arg_num, arg_type in enumerate(callback_parameters):
arg_name = 'arg%i' % (arg_num+1)
param_ctype = ctypeparser.parse_type(arg_type)
if ('const' in param_ctype.remove_modifiers()):
kwargs = {'is_const': True}
else:
kwargs = {}
try:
arguments.append(Parameter.new(str(param_ctype), arg_name, **kwargs))
except (typehandlers.TypeLookupError, typehandlers.TypeConfigurationError), ex:
warnings.warn("***** Unable to register callback; parameter '%s %s' error (used in %s): %r"
% (arg_type, arg_name, cls_name, ex),
Warning)
ok = False
def my_module_gen(out_file):
mod = Module("foo")
mod.add_include('"foo.h"')
mod.add_function("TypeNameGet", "std::string", [], custom_name="IntegerTypeNameGet", template_parameters=["int"])
Foo = mod.add_class("Foo", automatic_type_narrowing=True)
Foo.add_static_attribute("instance_count", ReturnValue.new("int"))
Foo.add_constructor([Parameter.new("std::string", "datum")])
Foo.add_constructor([])
Foo.add_method("get_datum", ReturnValue.new("const std::string"), [])
Foo.add_method("is_initialized", ReturnValue.new("bool"), [], is_const=True)
Foo.add_output_stream_operator()
Foo.add_method(
"add_sub",
ReturnValue.new("int"),
[
Parameter.new("int", "a"),
Parameter.new("int", "b", default_value="3"),
Parameter.new("bool", "subtract", default_value="false"),
],
is_static=True,
)
Zoo = mod.add_class("Zoo", automatic_type_narrowing=True)
Zoo.add_constructor([Parameter.new("std::string", "datum")])
Zoo.add_constructor([])
Zoo.add_method("get_datum", ReturnValue.new("std::string"), [])
Zoo.implicitly_converts_to(Foo)
Foobar = mod.add_class("Foobar", allow_subclassing=True)
Foobar.add_static_attribute("instance_count", ReturnValue.new("int"))
Bar = mod.add_class("Bar", parent=Foo)
Bar.inherit_default_constructors()
## a static method..
Bar.add_method("Hooray", ReturnValue.new("std::string"), [], is_static=True)
## to test RTTI with a hidden subclass
mod.add_function("get_hidden_subclass_pointer", ReturnValue.new("Foo*", caller_owns_return=True), [])
## Zbr is a reference counted class
Zbr = mod.add_class(
"Zbr",
memory_policy=cppclass.ReferenceCountingMethodsPolicy(
incref_method="Ref", decref_method="Unref", peekref_method="GetReferenceCount"
),
allow_subclassing=True,
)
def helper_class_hook(helper_class):
helper_class.add_custom_method(
declaration="static int custom_method_added_by_a_hook(int x);",
body="""
int %s::custom_method_added_by_a_hook(int x)
{
return x + 1;
}
"""
% helper_class.name,
)
helper_class.add_post_generation_code("// this comment was written by a helper class hook function")
Zbr.add_helper_class_hook(helper_class_hook)
Zbr.add_constructor([])
Zbr.add_constructor([Parameter.new("std::string", "datum")])
Zbr.add_method("get_datum", ReturnValue.new("std::string"), [])
Zbr.add_method("get_int", ReturnValue.new("int"), [Parameter.new("int", "x")], is_virtual=True)
Zbr.add_static_attribute("instance_count", ReturnValue.new("int"))
Zbr.add_method("get_value", ReturnValue.new("int"), [Parameter.new("int*", "x", direction=Parameter.DIRECTION_OUT)])
mod.add_function("store_zbr", None, [Parameter.new("Zbr*", "zbr", transfer_ownership=True)])
mod.add_function("invoke_zbr", ReturnValue.new("int"), [Parameter.new("int", "x")])
mod.add_function("delete_stored_zbr", None, [])
mod.add_function(
"print_something", ReturnValue.new("int"), [Parameter.new("const char*", "message")], deprecated=True
)
mod.add_function("print_something_else", ReturnValue.new("int"), [Parameter.new("const char*", "message2")])
## test overloaded functions
mod.add_function(
"get_int_from_string",
ReturnValue.new("int"),
[Parameter.new("const char*", "from_string"), Parameter.new("int", "multiplier", default_value="1")],
custom_name="get_int",
)
mod.add_function(
"get_int_from_float",
ReturnValue.new("int"),
[Parameter.new("double", "from_float"), Parameter.new("int", "multiplier", default_value="1")],
custom_name="get_int",
)
SomeObject = mod.add_class("SomeObject", allow_subclassing=True)
SomeObject.add_instance_attribute("foo", ReturnValue.new("Foo"), getter="get_foo_value", setter="set_foo_value")
SomeObject.add_instance_attribute("m_prefix", ReturnValue.new("std::string"))
SomeObject.add_static_attribute("staticData", ReturnValue.new("std::string"))
SomeObject.add_static_attribute("instance_count", ReturnValue.new("int"))
SomeObject.add_method(
"add_prefix",
ReturnValue.new("int"),
[Parameter.new("std::string&", "message", direction=Parameter.DIRECTION_INOUT)],
)
SomeObject.add_constructor([Parameter.new("std::string", "prefix")])
SomeObject.add_constructor([Parameter.new("int", "prefix_len")])
SomeObject.add_method(
"operator()",
ReturnValue.new("int"),
[Parameter.new("std::string&", "message", direction=Parameter.DIRECTION_INOUT)],
custom_name="__call__",
)
# --- some virtual methods ---
SomeObject.add_method("get_prefix", ReturnValue.new("std::string"), [], is_virtual=True, is_const=True)
SomeObject.add_method(
"get_prefix_with_foo_value",
ReturnValue.new("std::string"),
[Parameter.new("Foo", "foo")],
is_virtual=True,
is_const=True,
)
SomeObject.add_method(
"get_prefix_with_foo_ref",
ReturnValue.new("std::string"),
[Parameter.new("const Foo&", "foo", direction=Parameter.DIRECTION_INOUT)],
is_virtual=True,
is_const=True,
)
SomeObject.add_method(
"get_prefix_with_foo_ptr",
ReturnValue.new("std::string"),
[Parameter.new("const Foo*", "foo", transfer_ownership=False)],
is_virtual=True,
is_const=True,
)
## overloaded virtual methods
SomeObject.add_method("get_something", ReturnValue.new("std::string"), [], is_virtual=True, is_const=True)
SomeObject.add_method(
"get_something", ReturnValue.new("std::string"), [Parameter.new("int", "x")], is_virtual=True, is_const=True
)
SomeObject.add_method(
"set_pyobject", None, [Parameter.new("PyObject*", "pyobject", transfer_ownership=False)], is_virtual=True
)
SomeObject.add_method("get_pyobject", ReturnValue.new("PyObject*", caller_owns_return=True), [], is_virtual=True)
## add a function that appears as a method of an object
SomeObject.add_function_as_method(
"some_object_get_something_prefixed",
ReturnValue.new("std::string"),
[
Parameter.new("const SomeObject*", "obj", transfer_ownership=False),
Parameter.new("std::string", "something"),
],
custom_name="get_something_prefixed",
)
## add a function that appears as a method of an object
SomeObject.add_function_as_method(
"some_object_val_get_something_prefixed",
ReturnValue.new("std::string"),
[Parameter.new("SomeObject", "obj"), Parameter.new("std::string", "something")],
custom_name="val_get_something_prefixed",
)
## add a function that appears as a method of an object
SomeObject.add_function_as_method(
"some_object_ref_get_something_prefixed",
ReturnValue.new("std::string"),
[Parameter.new("const SomeObject&", "obj"), Parameter.new("std::string", "something")],
custom_name="ref_get_something_prefixed",
)
# ---
SomeObject.add_method("call_get_prefix", ReturnValue.new("std::string"), [])
SomeObject.add_method("set_foo_value", None, [Parameter.new("Foo", "foo")])
SomeObject.add_method("get_foo_value", ReturnValue.new("Foo"), [])
SomeObject.add_method(
"set_foo_ptr", ReturnValue.new("void"), [Parameter.new("Foo*", "foo", transfer_ownership=True)]
)
SomeObject.add_method(
"set_foo_shared_ptr", ReturnValue.new("void"), [Parameter.new("Foo*", "foo", transfer_ownership=False)]
)
SomeObject.add_method("get_foo_shared_ptr", ReturnValue.new("Foo*", caller_owns_return=False), [])
SomeObject.add_method("get_foo_ptr", ReturnValue.new("Foo*", caller_owns_return=True), [])
SomeObject.add_method(
"set_foo_by_ref", ReturnValue.new("void"), [Parameter.new("Foo&", "foo", direction=Parameter.DIRECTION_IN)]
)
SomeObject.add_method(
"get_foo_by_ref", ReturnValue.new("void"), [Parameter.new("Foo&", "foo", direction=Parameter.DIRECTION_OUT)]
)
## custodian/ward tests
SomeObject.add_method(
"get_foobar_with_self_as_custodian", ReturnValue.new("Foobar*", custodian=0, reference_existing_object=True), []
)
SomeObject.add_method(
"get_foobar_with_other_as_custodian",
ReturnValue.new("Foobar*", custodian=1, reference_existing_object=True),
[Parameter.new("SomeObject*", "other", transfer_ownership=False)],
)
SomeObject.add_method(
"set_foobar_with_self_as_custodian",
ReturnValue.new("void"),
[Parameter.new("Foobar*", "foobar", transfer_ownership=True, custodian=0)],
)
mod.add_function(
"get_foobar_with_other_as_custodian",
ReturnValue.new("Foobar*", custodian=1, reference_existing_object=True),
[Parameter.new("SomeObject*", "other", transfer_ownership=False)],
)
mod.add_function("create_new_foobar", ReturnValue.new("Foobar*", caller_owns_return=True), [])
mod.add_function(
"set_foobar_with_other_as_custodian",
ReturnValue.new("void"),
[
Parameter.new("Foobar*", "foobar", transfer_ownership=True, custodian=2),
Parameter.new("SomeObject*", "other", transfer_ownership=False),
],
)
mod.add_function(
"set_foobar_with_return_as_custodian",
ReturnValue.new("SomeObject*", caller_owns_return=True),
[Parameter.new("Foobar*", "foobar", transfer_ownership=True, custodian=-1)],
)
## get/set recfcounted object Zbr
SomeObject.add_method("get_zbr", ReturnValue.new("Zbr*", caller_owns_return=True), [])
SomeObject.add_method("get_internal_zbr", ReturnValue.new("Zbr*", caller_owns_return=True), [])
SomeObject.add_method("peek_zbr", ReturnValue.new("Zbr*", caller_owns_return=False), [])
SomeObject.add_method(
"set_zbr_transfer", ReturnValue.new("void"), [Parameter.new("Zbr*", "zbr", transfer_ownership=True)]
)
SomeObject.add_method(
"set_zbr_shared", ReturnValue.new("void"), [Parameter.new("Zbr*", "zbr", transfer_ownership=False)]
)
## methods with transformed types
SomeObject.add_method("set_zbr_pholder", ReturnValue.new("void"), [Parameter.new("PointerHolder<Zbr>", "zbr")])
SomeObject.add_method("get_zbr_pholder", ReturnValue.new("PointerHolder<Zbr>"), [])
## test overloaded methods
SomeObject.add_method(
"get_int", ReturnValue.new("int"), [Parameter.new("const char*", "from_string")], custom_name="get_int"
)
SomeObject.add_method(
"get_int", ReturnValue.new("int"), [Parameter.new("double", "from_float")], custom_name="get_int"
)
# Bug #508577
SomeObject.add_method(
"protected_method_that_is_not_virtual",
ReturnValue.new("std::string"),
[Parameter.new("std::string", "arg")],
is_const=True,
visibility="protected",
)
mod.add_function(
"store_some_object", ReturnValue.new("void"), [Parameter.new("SomeObject*", "obj", transfer_ownership=True)]
)
mod.add_function("invoke_some_object_get_prefix", ReturnValue.new("std::string"), [])
mod.add_function("take_some_object", ReturnValue.new("SomeObject*", caller_owns_return=True), [])
mod.add_function("delete_some_object", ReturnValue.new("void"), [])
xpto = mod.add_cpp_namespace("xpto")
xpto.add_function("some_function", ReturnValue.new("std::string"), [])
## enums..
xpto.add_enum("FooType", ["FOO_TYPE_AAA", "FOO_TYPE_BBB", "FOO_TYPE_CCC"])
xpto.add_function("get_foo_type", ReturnValue.new("FooType"), [])
xpto.add_function("set_foo_type", ReturnValue.new("void"), [Parameter.new("FooType", "type")])
xpto.add_function(
"set_foo_type_inout",
ReturnValue.new("void"),
[Parameter.new("FooType&", "type", direction=Parameter.DIRECTION_INOUT)],
)
xpto.add_function(
"set_foo_type_ptr",
ReturnValue.new("void"),
[Parameter.new("FooType*", "type", direction=Parameter.DIRECTION_INOUT)],
)
xpto_SomeClass = xpto.add_class("SomeClass", docstring="This is the docstring for SomeClass")
xpto_SomeClass.add_constructor([])
xpto.add_typedef(Foo, "FooXpto")
xpto.add_function("get_foo_datum", "std::string", [Parameter.new("const xpto::FooXpto&", "foo")])
typehandlers.add_type_alias("uint32_t", "xpto::FlowId")
xpto.add_function("get_flow_id", "xpto::FlowId", [Parameter.new("xpto::FlowId", "flowId")])
## ---- some implicity conversion APIs
mod.add_function("function_that_takes_foo", ReturnValue.new("void"), [Parameter.new("Foo", "foo")])
mod.add_function("function_that_returns_foo", ReturnValue.new("Foo"), [])
cls = mod.add_class("ClassThatTakesFoo")
cls.add_constructor([Parameter.new("Foo", "foo")])
cls.add_method("get_foo", ReturnValue.new("Foo"), [])
cls = mod.add_class("SingletonClass", is_singleton=True)
cls.add_method("GetInstance", ReturnValue.new("SingletonClass*", caller_owns_return=True), [], is_static=True)
## A class that has no public default constructor...
cls = mod.add_class("InterfaceId", is_singleton=True)
## A function that returns such a class...
mod.add_function("make_interface_id", ReturnValue.new("InterfaceId"), [])
## A class the cannot be constructed; this will cause late CodeGenerationError's
cls = mod.add_class("CannotBeConstructed")
cls.set_cannot_be_constructed("no reason")
cls.add_method("get_value", ReturnValue.new("CannotBeConstructed"), [], is_static=True)
cls.add_method("get_ptr", ReturnValue.new("CannotBeConstructed*", caller_owns_return=True), [], is_static=True)
mod.add_function("get_cannot_be_constructed_value", ReturnValue.new("CannotBeConstructed"), [])
mod.add_function(
"get_cannot_be_constructed_ptr", ReturnValue.new("CannotBeConstructed*", caller_owns_return=True), []
)
## A nested class
# NestedClass = mod.add_class('NestedClass', automatic_type_narrowing=True, outer_class=SomeObject)
NestedClass = SomeObject.add_class("NestedClass", automatic_type_narrowing=True)
NestedClass.add_static_attribute("instance_count", ReturnValue.new("int"))
NestedClass.add_constructor([Parameter.new("std::string", "datum")])
NestedClass.add_constructor([])
NestedClass.add_method("get_datum", ReturnValue.new("std::string"), [])
## A nested enum..
# mod.add_enum('NestedEnum', ['FOO_TYPE_AAA', 'FOO_TYPE_BBB', 'FOO_TYPE_CCC'], outer_class=SomeObject)
SomeObject.add_enum("NestedEnum", ["FOO_TYPE_AAA", "FOO_TYPE_BBB", "FOO_TYPE_CCC"])
## anonymous enum
SomeObject.add_enum("", ["CONSTANT_A", "CONSTANT_B", "CONSTANT_C"])
AbstractBaseClass2 = mod.add_class("AbstractBaseClass2", allow_subclassing=True)
AbstractBaseClass2.add_method(
"invoke_private_virtual", ReturnValue.new("int"), [Parameter.new("int", "x")], is_const=True
)
AbstractBaseClass2.add_method(
"invoke_protected_virtual", ReturnValue.new("int"), [Parameter.new("int", "x")], is_const=True
)
AbstractBaseClass2.add_method(
"invoke_protected_pure_virtual", ReturnValue.new("int"), [Parameter.new("int", "x")], is_const=True
)
AbstractBaseClass2.add_constructor([], visibility="protected")
AbstractBaseClass2.add_method(
"protected_virtual",
ReturnValue.new("int"),
[Parameter.new("int", "x")],
is_virtual=True,
visibility="protected",
is_const=True,
)
AbstractBaseClass2.add_method(
"protected_pure_virtual",
ReturnValue.new("int"),
[Parameter.new("int", "x")],
is_virtual=True,
is_pure_virtual=True,
visibility="protected",
is_const=True,
)
AbstractBaseClass2.add_method(
"private_virtual",
ReturnValue.new("int"),
[Parameter.new("int", "x")],
is_virtual=True,
is_pure_virtual=True,
visibility="private",
is_const=True,
)
AbstractXpto = mod.add_class("AbstractXpto", allow_subclassing=True)
AbstractXpto.add_method(
"something",
ReturnValue.new("void"),
[Parameter.new("int", "x")],
is_const=True,
is_virtual=True,
is_pure_virtual=True,
)
AbstractXpto.add_constructor([])
AbstractXptoImpl = mod.add_class("AbstractXptoImpl", parent=AbstractXpto)
AbstractXptoImpl.add_method(
"something",
ReturnValue.new("void"),
[Parameter.new("int", "x")],
is_const=True,
is_virtual=True,
is_pure_virtual=False,
)
AbstractXptoImpl.add_constructor([])
Word = mod.add_class("Word")
Word.add_instance_attribute("low", "uint8_t", is_const=False)
Word.add_instance_attribute("high", "uint8_t", is_const=False)
Word.add_instance_attribute("word", "uint16_t", is_const=False)
Word.add_constructor([])
mod.add_function(
"matrix_sum_of_elements",
ReturnValue.new("float"),
[Parameter.new("float*", "matrix", direction=Parameter.DIRECTION_IN, array_length=6)],
)
mod.add_function(
"matrix_identity_new",
ReturnValue.new("void"),
[Parameter.new("float*", "matrix", direction=Parameter.DIRECTION_OUT, array_length=6)],
)
top_ns = mod.add_cpp_namespace("TopNs")
outer_base = top_ns.add_class("OuterBase")
bottom_ns = top_ns.add_cpp_namespace("PrefixBottomNs")
inner = bottom_ns.add_class("PrefixInner", parent=outer_base)
inner.add_constructor([])
inner.add_method("Do", "void", [])
Socket = mod.add_class("Socket", allow_subclassing=True)
Socket.add_constructor([])
Socket.add_method("Bind", ReturnValue.new("int"), [], is_virtual=True)
Socket.add_method("Bind", ReturnValue.new("int"), [Parameter.new("int", "address")], is_virtual=True)
UdpSocket = mod.add_class("UdpSocket", parent=Socket)
UdpSocket.add_constructor([])
UdpSocket.add_method("Bind", ReturnValue.new("int"), [], is_virtual=True)
simple_struct_t = mod.add_struct("simple_struct_t")
simple_struct_t.add_instance_attribute("xpto", "int")
# containers...
mod.add_container("SimpleStructList", ReturnValue.new("simple_struct_t"), "list")
mod.add_function("get_simple_list", ReturnValue.new("SimpleStructList"), [])
mod.add_function("set_simple_list", "int", [Parameter.new("SimpleStructList", "list")])
mod.add_container("std::set<float>", "float", "set")
TestContainer = mod.add_class("TestContainer", allow_subclassing=True)
TestContainer.add_constructor([])
TestContainer.add_instance_attribute("m_floatSet", "std::set<float>")
TestContainer.add_method("get_simple_list", ReturnValue.new("SimpleStructList"), [], is_virtual=True)
TestContainer.add_method("set_simple_list", "int", [Parameter.new("SimpleStructList", "list")], is_virtual=True)
TestContainer.add_method(
"set_simple_list_by_ref",
"int",
[Parameter.new("SimpleStructList&", "inout_list", direction=Parameter.DIRECTION_INOUT)],
is_virtual=True,
)
mod.add_container("std::vector<simple_struct_t>", ReturnValue.new("simple_struct_t"), "vector")
TestContainer.add_method("get_simple_vec", ReturnValue.new("std::vector<simple_struct_t>"), [], is_virtual=True)
TestContainer.add_method(
"set_simple_vec", "int", [Parameter.new("std::vector<simple_struct_t>", "vec")], is_virtual=True
)
mod.add_container("std::vector<std::string>", "std::string", "vector")
TestContainer.add_method(
"get_vec", "void", [Parameter.new("std::vector<std::string> &", "outVec", direction=Parameter.DIRECTION_OUT)]
)
TestContainer.add_method(
"set_vec_ptr",
"void",
[
Parameter.new(
"std::vector<std::string>*", "inVec", direction=Parameter.DIRECTION_IN, transfer_ownership=True
)
],
)
TestContainer.add_method(
"get_vec_ptr", "void", [Parameter.new("std::vector<std::string>*", "outVec", direction=Parameter.DIRECTION_OUT)]
)
mod.add_container(
"std::map<std::string, simple_struct_t>",
(ReturnValue.new("std::string"), ReturnValue.new("simple_struct_t")),
"map",
)
TestContainer.add_method(
"get_simple_map", ReturnValue.new("std::map<std::string, simple_struct_t>"), [], is_virtual=True
)
TestContainer.add_method(
"set_simple_map", "int", [Parameter.new("std::map<std::string, simple_struct_t>", "map")], is_virtual=True
)
Tupl = mod.add_class("Tupl")
Tupl.add_binary_comparison_operator("<")
Tupl.add_binary_comparison_operator("<=")
Tupl.add_binary_comparison_operator(">=")
Tupl.add_binary_comparison_operator(">")
Tupl.add_binary_comparison_operator("==")
Tupl.add_binary_comparison_operator("!=")
Tupl.add_binary_numeric_operator("+")
Tupl.add_binary_numeric_operator("-")
Tupl.add_binary_numeric_operator("*")
Tupl.add_binary_numeric_operator("/")
Tupl.add_instance_attribute("x", "int", is_const=False)
Tupl.add_instance_attribute("y", "int", is_const=False)
Tupl.add_constructor([Parameter.new("Tupl const &", "arg0")])
Tupl.add_constructor([])
Tupl.add_inplace_numeric_operator("+=")
Tupl.add_inplace_numeric_operator("-=")
Tupl.add_inplace_numeric_operator("*=")
Tupl.add_inplace_numeric_operator("/=")
Tupl.add_unary_numeric_operator("-")
Tupl.add_inplace_numeric_operator("+=", right="int")
ManipulatedObject = mod.add_class("ManipulatedObject")
ManipulatedObject.add_constructor([])
ManipulatedObject.add_method("GetValue", "int", [], is_const=True)
ManipulatedObject.add_method("SetValue", "void", [Parameter.new("int", "value")])
ReferenceManipulator = mod.add_class("ReferenceManipulator", allow_subclassing=True)
ReferenceManipulator.add_constructor([])
ReferenceManipulator.add_method("manipulate_object", "int", [])
ReferenceManipulator.add_method(
"do_manipulate_object",
"void",
[Parameter.new("ManipulatedObject&", "obj", direction=Parameter.DIRECTION_INOUT)],
is_virtual=True,
is_pure_virtual=True,
)
VectorLike = mod.add_class("VectorLike")
VectorLike.add_constructor([])
VectorLike.add_method("append", "void", [Parameter.new("double", "value")])
VectorLike.add_method("get_item", "double", [Parameter.new("size_t", "index")], custom_name="__getitem__")
VectorLike.add_method(
"set_item",
"void",
[Parameter.new("size_t", "index"), Parameter.new("double", "value")],
custom_name="__setitem__",
)
VectorLike.add_method("get_len", "size_t", [], custom_name="__len__")
VectorLike2 = mod.add_class("VectorLike2")
VectorLike2.add_constructor([])
VectorLike2.add_method("append", "void", [Parameter.new("double", "value")])
MapLike = mod.add_class("MapLike")
MapLike.add_constructor([])
MapLike.add_method("set", "void", [Parameter.new("int", "key"), Parameter.new("double", "value")])
Error = mod.add_exception("Error")
DomainError = mod.add_exception("DomainError", parent=Error)
mod.add_function("my_inverse_func", "double", [Parameter.new("double", "x")], throw=[DomainError])
ClassThatThrows = mod.add_class("ClassThatThrows", allow_subclassing=True)
ClassThatThrows.add_constructor([Parameter.new("double", "x")], throw=[DomainError])
ClassThatThrows.add_method("my_inverse_method", "double", [Parameter.new("double", "x")], throw=[DomainError])
std_exception = mod.add_exception("exception", foreign_cpp_namespace="std", message_rvalue="%(EXC)s.what()")
mod.add_function("my_inverse_func2", "double", [Parameter.new("double", "x")], throw=[std_exception])
ClassThatThrows.add_method("my_inverse_method2", "double", [Parameter.new("double", "x")], throw=[std_exception])
ClassThatThrows.add_method("throw_error", "int", [], throw=[std_exception], is_const=True, is_virtual=True)
# https://bugs.launchpad.net/pybindgen/+bug/450255
ProtectedConstructor = mod.add_class("ProtectedConstructor")
ProtectedConstructor.add_constructor([])
ProtectedConstructor.add_constructor([Parameter.new("ProtectedConstructor&", "c")], visibility="protected")
# https://bugs.launchpad.net/pybindgen/+bug/455689
property_std_string = mod.add_struct("property", template_parameters=["std::string"])
Box = mod.add_class("Box")
Box.add_constructor([])
Box.add_static_attribute("instance_count", ReturnValue.new("int"))
Box.add_method("getFoobarInternalPtr", ReturnValue.new("Foobar*", reference_existing_object=True), [])
Box.add_method("getFoobarInternalRef", ReturnValue.new("Foobar&", reference_existing_object=True), [])
Box.add_method("getFoobarInternalPtr2", ReturnValue.new("Foobar*", return_internal_reference=True), [])
Box.add_method("getFoobarInternalRef2", ReturnValue.new("Foobar&", return_internal_reference=True), [])
Box.add_instance_attribute("m_internalFoobar", ReturnValue.new("Foobar*", reference_existing_object=True))
# multiple inheritance
MIRoot = mod.add_class("MIRoot")
MIRoot.add_constructor([])
MIRoot.add_method("root_method", "int", [], is_const=True)
MIBase1 = mod.add_class("MIBase1", parent=MIRoot)
MIBase1.add_constructor([])
MIBase1.add_method("base1_method", "int", [], is_const=True)
MIBase2 = mod.add_class("MIBase2", parent=MIRoot)
MIBase2.add_constructor([])
MIBase2.add_method("base2_method", "int", [], is_const=True)
MIMixed = mod.add_class("MIMixed", parent=[MIBase1, MIBase2])
MIMixed.add_constructor([])
MIMixed.add_method("mixed_method", "int", [], is_const=True)
#### --- error handler ---
class MyErrorHandler(pybindgen.settings.ErrorHandler):
def __init__(self):
super(MyErrorHandler, self).__init__()
self.num_errors = 0
def handle_error(self, wrapper, exception, traceback_):
print >>sys.stderr, "exception %s in wrapper %s" % (exception, wrapper)
self.num_errors += 1
if 0: # verbose?
import traceback
traceback.print_tb(traceback_)
return True
pybindgen.settings.error_handler = MyErrorHandler()
foomodulegen_common.customize_module(mod)
## ---- finally, generate the whole thing ----
mod.generate(FileCodeSink(out_file))
def generate_callback_classes(out, callbacks):
for callback_impl_num, template_parameters in enumerate(callbacks):
sink = MemoryCodeSink()
cls_name = "ns3::Callback< %s >" % ', '.join(template_parameters)
#print >> sys.stderr, "***** trying to register callback: %r" % cls_name
class_name = "PythonCallbackImpl%i" % callback_impl_num
sink.writeln('''
class %s : public ns3::CallbackImpl<%s>
{
public:
PyObject *m_callback;
%s(PyObject *callback)
{
Py_INCREF(callback);
m_callback = callback;
}
virtual ~%s()
{
PyGILState_STATE __py_gil_state;
__py_gil_state = (PyEval_ThreadsInitialized() ? PyGILState_Ensure() : (PyGILState_STATE) 0);
Py_DECREF(m_callback);
m_callback = NULL;
PyGILState_Release(__py_gil_state);
}
virtual bool IsEqual(ns3::Ptr<const ns3::CallbackImplBase> other_base) const
{
const %s *other = dynamic_cast<const %s*> (ns3::PeekPointer (other_base));
if (other != NULL)
return (other->m_callback == m_callback);
else
return false;
}
''' % (class_name, ', '.join(template_parameters), class_name, class_name,
class_name, class_name))
sink.indent()
callback_return = template_parameters[0]
return_ctype = ctypeparser.parse_type(callback_return)
if ('const' in return_ctype.remove_modifiers()):
kwargs = {'is_const': True}
else:
kwargs = {}
try:
return_type = ReturnValue.new(str(return_ctype), **kwargs)
except (typehandlers.TypeLookupError,
typehandlers.TypeConfigurationError) as ex:
warnings.warn(
"***** Unable to register callback; Return value '%s' error (used in %s): %r"
% (callback_return, cls_name, ex), Warning)
continue
arguments = []
ok = True
callback_parameters = [
arg for arg in template_parameters[1:] if arg != 'ns3::empty'
]
for arg_num, arg_type in enumerate(callback_parameters):
arg_name = 'arg%i' % (arg_num + 1)
param_ctype = ctypeparser.parse_type(arg_type)
if ('const' in param_ctype.remove_modifiers()):
kwargs = {'is_const': True}
else:
kwargs = {}
try:
arguments.append(
Parameter.new(str(param_ctype), arg_name, **kwargs))
except (typehandlers.TypeLookupError,
typehandlers.TypeConfigurationError) as ex:
warnings.warn(
"***** Unable to register callback; parameter '%s %s' error (used in %s): %r"
% (arg_type, arg_name, cls_name, ex), Warning)
ok = False
if not ok:
continue
wrapper = CallbackImplProxyMethod(return_type, arguments)
wrapper.generate(sink, 'operator()', decl_modifiers=[])
sink.unindent()
sink.writeln('};\n')
sink.flush_to(out)
class PythonCallbackParameter(Parameter):
"Class handlers"
CTYPES = [cls_name]
print("***** registering callback handler: %r" %
ctypeparser.normalize_type_string(cls_name),
file=sys.stderr)
DIRECTIONS = [Parameter.DIRECTION_IN]
PYTHON_CALLBACK_IMPL_NAME = class_name
TEMPLATE_ARGS = template_parameters
def convert_python_to_c(self, wrapper):
"parses python args to get C++ value"
assert isinstance(wrapper, typehandlers.ForwardWrapperBase)
if self.default_value is None:
py_callback = wrapper.declarations.declare_variable(
'PyObject*', self.name)
wrapper.parse_params.add_parameter('O',
['&' + py_callback],
self.name)
wrapper.before_call.write_error_check(
'!PyCallable_Check(%s)' % py_callback,
'PyErr_SetString(PyExc_TypeError, "parameter \'%s\' must be callbale");'
% self.name)
callback_impl = wrapper.declarations.declare_variable(
'ns3::Ptr<%s>' % self.PYTHON_CALLBACK_IMPL_NAME,
'%s_cb_impl' % self.name)
wrapper.before_call.write_code(
"%s = ns3::Create<%s> (%s);" %
(callback_impl, self.PYTHON_CALLBACK_IMPL_NAME,
py_callback))
wrapper.call_params.append(
'ns3::Callback<%s> (%s)' %
(', '.join(self.TEMPLATE_ARGS), callback_impl))
else:
py_callback = wrapper.declarations.declare_variable(
'PyObject*', self.name, 'NULL')
wrapper.parse_params.add_parameter('O',
['&' + py_callback],
self.name,
optional=True)
value = wrapper.declarations.declare_variable(
'ns3::Callback<%s>' % ', '.join(self.TEMPLATE_ARGS),
self.name + '_value', self.default_value)
wrapper.before_call.write_code("if (%s) {" %
(py_callback, ))
wrapper.before_call.indent()
wrapper.before_call.write_error_check(
'!PyCallable_Check(%s)' % py_callback,
'PyErr_SetString(PyExc_TypeError, "parameter \'%s\' must be callbale");'
% self.name)
wrapper.before_call.write_code(
"%s = ns3::Callback<%s> (ns3::Create<%s> (%s));" %
(value, ', '.join(self.TEMPLATE_ARGS),
self.PYTHON_CALLBACK_IMPL_NAME, py_callback))
wrapper.before_call.unindent()
wrapper.before_call.write_code(
"}") # closes: if (py_callback) {
wrapper.call_params.append(value)
def convert_c_to_python(self, wrapper):
raise typehandlers.NotSupportedError(
"Reverse wrappers for ns3::Callback<...> types "
"(python using callbacks defined in C++) not implemented.")
def my_module_gen(out_file):
mod = Module('foo')
mod.add_include ('"foo.h"')
mod.add_function('TypeNameGet',
'std::string',
[],
custom_name='IntegerTypeNameGet', template_parameters=['int'])
Foo = mod.add_class('Foo', automatic_type_narrowing=True)
Foo.add_static_attribute('instance_count', ReturnValue.new('int'))
Foo.add_constructor([Parameter.new('std::string', 'datum')])
Foo.add_constructor([])
Foo.add_method('get_datum', ReturnValue.new('const std::string'), [])
Foo.add_method('is_initialized', ReturnValue.new('bool'), [], is_const=True)
Foo.add_output_stream_operator()
Foo.add_method('add_sub', ReturnValue.new('int'), [
Parameter.new('int', 'a'),
Parameter.new('int', 'b', default_value='3'),
Parameter.new('bool', 'subtract', default_value='false')
], is_static=True)
Foo.add_custom_instance_attribute("is_unique", "bool", getter="is_unique", is_const=True)
Zoo = mod.add_class('Zoo', automatic_type_narrowing=True)
Zoo.add_constructor([Parameter.new('std::string', 'datum')])
Zoo.add_constructor([])
Zoo.add_method('get_datum', ReturnValue.new('std::string'), [])
Zoo.implicitly_converts_to(Foo)
Foobar = mod.add_class('Foobar', allow_subclassing=True)
Foobar.add_static_attribute('instance_count', ReturnValue.new('int'))
Bar = mod.add_class('Bar', parent=Foo)
Bar.inherit_default_constructors()
## a static method..
Bar.add_method('Hooray', ReturnValue.new('std::string'), [], is_static=True)
## to test RTTI with a hidden subclass
mod.add_function('get_hidden_subclass_pointer',
ReturnValue.new('Foo*', caller_owns_return=True),
[])
## Zbr is a reference counted class
Zbr = mod.add_class('Zbr', memory_policy=cppclass.ReferenceCountingMethodsPolicy(
incref_method='Ref', decref_method='Unref', peekref_method="GetReferenceCount"),
allow_subclassing=True)
def helper_class_hook(helper_class):
helper_class.add_custom_method(
declaration="static int custom_method_added_by_a_hook(int x);",
body="""
int %s::custom_method_added_by_a_hook(int x)
{
return x + 1;
}
""" % helper_class.name)
helper_class.add_post_generation_code("// this comment was written by a helper class hook function")
Zbr.add_helper_class_hook(helper_class_hook)
Zbr.add_constructor([])
Zbr.add_constructor([Parameter.new('std::string', 'datum')])
Zbr.add_method('get_datum', ReturnValue.new('std::string'), [])
Zbr.add_method('get_int', ReturnValue.new('int'), [Parameter.new('int', 'x')],
is_virtual=True)
Zbr.add_static_attribute('instance_count', ReturnValue.new('int'))
Zbr.add_method('get_value', ReturnValue.new('int'), [Parameter.new('int*', 'x', direction=Parameter.DIRECTION_OUT)])
mod.add_function('store_zbr', None,
[Parameter.new('Zbr*', 'zbr', transfer_ownership=True)])
mod.add_function('invoke_zbr', ReturnValue.new('int'), [Parameter.new('int', 'x')])
mod.add_function('delete_stored_zbr', None, [])
mod.add_function('print_something', ReturnValue.new('int'),
[Parameter.new('const char*', 'message')],
deprecated=True)
mod.add_function('print_something_else', ReturnValue.new('int'),
[Parameter.new('const char*', 'message2')])
## test overloaded functions
mod.add_function('get_int_from_string', ReturnValue.new('int'),
[Parameter.new('const char*', 'from_string'),
Parameter.new('int', 'multiplier', default_value='1')], custom_name="get_int")
mod.add_function('get_int_from_float', ReturnValue.new('int'),
[Parameter.new('double', 'from_float'),
Parameter.new('int', 'multiplier', default_value='1')],
custom_name="get_int")
SomeObject = mod.add_class('SomeObject', allow_subclassing=True)
SomeObject.add_instance_attribute('foo', ReturnValue.new('Foo'),
getter='get_foo_value',
setter='set_foo_value')
SomeObject.add_instance_attribute('m_prefix', ReturnValue.new('std::string'))
SomeObject.add_static_attribute('staticData', ReturnValue.new('std::string'))
SomeObject.add_static_attribute('instance_count', ReturnValue.new('int'))
SomeObject.add_method('add_prefix', ReturnValue.new('int'),
[Parameter.new('std::string&', 'message',
direction=Parameter.DIRECTION_INOUT)])
SomeObject.add_constructor([Parameter.new('std::string', 'prefix')])
SomeObject.add_constructor([Parameter.new('int', 'prefix_len')])
SomeObject.add_method('operator()', ReturnValue.new('int'),
[Parameter.new('std::string&', 'message',
direction=Parameter.DIRECTION_INOUT)],
custom_name='__call__')
# --- some virtual methods ---
SomeObject.add_method('get_prefix', ReturnValue.new('std::string'), [],
is_virtual=True, is_const=True)
SomeObject.add_method('get_prefix_with_foo_value', ReturnValue.new('std::string'),
[Parameter.new('Foo', 'foo')],
is_virtual=True, is_const=True)
SomeObject.add_method('get_prefix_with_foo_ref',
ReturnValue.new('std::string'),
[Parameter.new('const Foo&', 'foo',
direction=Parameter.DIRECTION_INOUT)],
is_virtual=True, is_const=True)
SomeObject.add_method('get_prefix_with_foo_ptr',
ReturnValue.new('std::string'),
[Parameter.new('const Foo*', 'foo', transfer_ownership=False)],
is_virtual=True, is_const=True)
## overloaded virtual methods
SomeObject.add_method('get_something',
ReturnValue.new('std::string'),
[],
is_virtual=True, is_const=True)
SomeObject.add_method('get_something',
ReturnValue.new('std::string'),
[Parameter.new('int', 'x')],
is_virtual=True, is_const=True)
SomeObject.add_method('set_pyobject', None,
[Parameter.new('PyObject*', 'pyobject', transfer_ownership=False)],
is_virtual=True)
SomeObject.add_method('get_pyobject',
ReturnValue.new('PyObject*', caller_owns_return=True),
[],
is_virtual=True)
## add a function that appears as a method of an object
SomeObject.add_function_as_method('some_object_get_something_prefixed',
ReturnValue.new('std::string'),
[Parameter.new('const SomeObject*', 'obj', transfer_ownership=False),
Parameter.new('std::string', 'something')],
custom_name='get_something_prefixed')
## add a function that appears as a method of an object
SomeObject.add_function_as_method('some_object_val_get_something_prefixed',
ReturnValue.new('std::string'),
[Parameter.new('SomeObject', 'obj'),
Parameter.new('std::string', 'something')],
custom_name='val_get_something_prefixed')
## add a function that appears as a method of an object
SomeObject.add_function_as_method('some_object_ref_get_something_prefixed',
ReturnValue.new('std::string'),
[Parameter.new('const SomeObject&', 'obj'),
Parameter.new('std::string', 'something')],
custom_name='ref_get_something_prefixed')
# ---
SomeObject.add_method('call_get_prefix', ReturnValue.new('std::string'), [])
SomeObject.add_method('set_foo_value', None, [Parameter.new('Foo', 'foo')])
SomeObject.add_method('get_foo_value', ReturnValue.new('Foo'), [])
SomeObject.add_method('set_foo_ptr', ReturnValue.new('void'),
[Parameter.new('Foo*', 'foo', transfer_ownership=True)])
SomeObject.add_method('set_foo_shared_ptr', ReturnValue.new('void'),
[Parameter.new('Foo*', 'foo', transfer_ownership=False)])
SomeObject.add_method('get_foo_shared_ptr', ReturnValue.new('const Foo*', caller_owns_return=False), [])
SomeObject.add_method('get_foo_ptr', ReturnValue.new('Foo*', caller_owns_return=True), [])
SomeObject.add_method('set_foo_by_ref', ReturnValue.new('void'),
[Parameter.new('Foo&', 'foo', direction=Parameter.DIRECTION_IN)])
SomeObject.add_method('get_foo_by_ref', ReturnValue.new('void'),
[Parameter.new('Foo&', 'foo', direction=Parameter.DIRECTION_OUT)])
## custodian/ward tests
SomeObject.add_method('get_foobar_with_self_as_custodian',
ReturnValue.new('Foobar*', custodian=0, reference_existing_object=True), [])
SomeObject.add_method('get_foobar_with_other_as_custodian',
ReturnValue.new('Foobar*', custodian=1, reference_existing_object=True),
[Parameter.new('SomeObject*', 'other', transfer_ownership=False)])
SomeObject.add_method('set_foobar_with_self_as_custodian', ReturnValue.new('void'),
[Parameter.new('Foobar*', 'foobar',
transfer_ownership=True, custodian=0)])
mod.add_function('get_foobar_with_other_as_custodian',
ReturnValue.new('Foobar*', custodian=1, reference_existing_object=True),
[Parameter.new('SomeObject*', 'other', transfer_ownership=False)])
mod.add_function('create_new_foobar', ReturnValue.new('Foobar*', caller_owns_return=True), [])
mod.add_function('set_foobar_with_other_as_custodian', ReturnValue.new('void'),
[Parameter.new('Foobar*', 'foobar', transfer_ownership=True, custodian=2),
Parameter.new('SomeObject*', 'other', transfer_ownership=False)])
mod.add_function('set_foobar_with_return_as_custodian',
ReturnValue.new('SomeObject*', caller_owns_return=True),
[Parameter.new('Foobar*', 'foobar',
transfer_ownership=True, custodian=-1)])
## get/set recfcounted object Zbr
SomeObject.add_method('get_zbr', ReturnValue.new('Zbr*', caller_owns_return=True), [])
SomeObject.add_method('get_internal_zbr', ReturnValue.new('Zbr*', caller_owns_return=True), [])
SomeObject.add_method('peek_zbr', ReturnValue.new('Zbr*', caller_owns_return=False), [])
SomeObject.add_method('set_zbr_transfer', ReturnValue.new('void'),
[Parameter.new('Zbr*', 'zbr', transfer_ownership=True)])
SomeObject.add_method('set_zbr_shared', ReturnValue.new('void'),
[Parameter.new('Zbr*', 'zbr', transfer_ownership=False)])
## methods with transformed types
SomeObject.add_method('set_zbr_pholder', ReturnValue.new('void'),
[Parameter.new('PointerHolder<Zbr>', 'zbr')])
SomeObject.add_method('get_zbr_pholder',
ReturnValue.new('PointerHolder<Zbr>'), [])
## test overloaded methods
SomeObject.add_method('get_int', ReturnValue.new('int'),
[Parameter.new('const char*', 'from_string')],
custom_name="get_int")
SomeObject.add_method('get_int', ReturnValue.new('int'),
[Parameter.new('double', 'from_float')],
custom_name="get_int")
# Bug #508577
SomeObject.add_method('protected_method_that_is_not_virtual',
ReturnValue.new('std::string'),
[Parameter.new('std::string', 'arg')],
is_const=True, visibility='protected')
SomeObject.add_method('method_returning_cstring', ReturnValue.new('const char *'),
[], is_virtual=True, is_const=True)
mod.add_function('store_some_object', ReturnValue.new('void'),
[Parameter.new('SomeObject*', 'obj', transfer_ownership=True)])
mod.add_function('invoke_some_object_get_prefix', ReturnValue.new('std::string'),
[])
mod.add_function('take_some_object', ReturnValue.new('SomeObject*', caller_owns_return=True), [])
mod.add_function('delete_some_object', ReturnValue.new('void'), [])
xpto = mod.add_cpp_namespace("xpto")
xpto.add_function('some_function', ReturnValue.new('std::string'), [])
## enums..
xpto.add_enum('FooType', ['FOO_TYPE_AAA', 'FOO_TYPE_BBB', 'FOO_TYPE_CCC'])
xpto.add_function('get_foo_type', ReturnValue.new('FooType'), [])
xpto.add_function('set_foo_type', ReturnValue.new('void'), [Parameter.new("FooType", 'type')])
xpto.add_function('set_foo_type_inout', ReturnValue.new('void'),
[Parameter.new("FooType&", 'type', direction=Parameter.DIRECTION_INOUT)])
xpto.add_function('set_foo_type_ptr', ReturnValue.new('void'),
[Parameter.new("FooType*", 'type', direction=Parameter.DIRECTION_INOUT)])
xpto_SomeClass = xpto.add_class('SomeClass', docstring="This is the docstring for SomeClass")
xpto_SomeClass.add_constructor([])
xpto.add_typedef(Foo, 'FooXpto')
xpto.add_function('get_foo_datum', 'std::string', [Parameter.new('const xpto::FooXpto&', 'foo')])
typehandlers.add_type_alias('uint32_t', 'xpto::FlowId')
xpto.add_function('get_flow_id', 'xpto::FlowId', [Parameter.new('xpto::FlowId', 'flowId')])
# bug #798383
XptoClass = xpto.add_struct('XptoClass')
XptoClass.add_method("GetSomeClass", retval("xpto::SomeClass*", caller_owns_return=True), [])
## ---- some implicity conversion APIs
mod.add_function('function_that_takes_foo', ReturnValue.new('void'),
[Parameter.new('Foo', 'foo')])
mod.add_function('function_that_returns_foo', ReturnValue.new('Foo'), [])
cls = mod.add_class('ClassThatTakesFoo')
cls.add_constructor([Parameter.new('Foo', 'foo')])
cls.add_method('get_foo', ReturnValue.new('Foo'), [])
cls = mod.add_class('SingletonClass', is_singleton=True)
cls.add_method('GetInstance', ReturnValue.new('SingletonClass*', caller_owns_return=True),
[], is_static=True)
## A class that has no public default constructor...
cls = mod.add_class('InterfaceId', is_singleton=True)
## A function that returns such a class...
mod.add_function('make_interface_id', ReturnValue.new('InterfaceId'), [])
## A class the cannot be constructed; this will cause late CodeGenerationError's
cls = mod.add_class('CannotBeConstructed')
cls.set_cannot_be_constructed("no reason")
cls.add_method('get_value', ReturnValue.new('CannotBeConstructed'),
[], is_static=True)
cls.add_method('get_ptr', ReturnValue.new('CannotBeConstructed*', caller_owns_return=True),
[], is_static=True)
mod.add_function('get_cannot_be_constructed_value',
ReturnValue.new('CannotBeConstructed'),
[])
mod.add_function('get_cannot_be_constructed_ptr',
ReturnValue.new('CannotBeConstructed*', caller_owns_return=True),
[])
## A nested class
#NestedClass = mod.add_class('NestedClass', automatic_type_narrowing=True, outer_class=SomeObject)
NestedClass = SomeObject.add_class('NestedClass', automatic_type_narrowing=True)
NestedClass.add_static_attribute('instance_count', ReturnValue.new('int'))
NestedClass.add_constructor([Parameter.new('std::string', 'datum')])
NestedClass.add_constructor([])
NestedClass.add_method('get_datum', ReturnValue.new('std::string'), [])
## A nested enum..
#mod.add_enum('NestedEnum', ['FOO_TYPE_AAA', 'FOO_TYPE_BBB', 'FOO_TYPE_CCC'], outer_class=SomeObject)
SomeObject.add_enum('NestedEnum', ['FOO_TYPE_AAA', 'FOO_TYPE_BBB', 'FOO_TYPE_CCC'])
## anonymous enum
SomeObject.add_enum('', ['CONSTANT_A', 'CONSTANT_B', 'CONSTANT_C'])
AbstractBaseClass2 = mod.add_class('AbstractBaseClass2', allow_subclassing=True)
AbstractBaseClass2.add_method('invoke_private_virtual', ReturnValue.new('int'),
[Parameter.new('int', 'x')], is_const=True)
AbstractBaseClass2.add_method('invoke_protected_virtual', ReturnValue.new('int'),
[Parameter.new('int', 'x')], is_const=True)
AbstractBaseClass2.add_method('invoke_protected_pure_virtual', ReturnValue.new('int'),
[Parameter.new('int', 'x')], is_const=True)
AbstractBaseClass2.add_constructor([], visibility='protected')
AbstractBaseClass2.add_method('protected_virtual',
ReturnValue.new('int'),
[Parameter.new('int', 'x')],
is_virtual=True, visibility='protected', is_const=True)
AbstractBaseClass2.add_method('protected_pure_virtual',
ReturnValue.new('int'),
[Parameter.new('int', 'x')],
is_virtual=True, is_pure_virtual=True, visibility='protected', is_const=True)
AbstractBaseClass2.add_method('private_virtual',
ReturnValue.new('int'), [Parameter.new('int', 'x')],
is_virtual=True, is_pure_virtual=True, visibility='private', is_const=True)
AbstractXpto = mod.add_class('AbstractXpto', allow_subclassing=True)
AbstractXpto.add_method('something', ReturnValue.new('void'),
[Parameter.new('int', 'x')], is_const=True,
is_virtual=True, is_pure_virtual=True)
AbstractXpto.add_constructor([])
AbstractXptoImpl = mod.add_class('AbstractXptoImpl', parent=AbstractXpto)
AbstractXptoImpl.add_method('something', ReturnValue.new('void'),
[Parameter.new('int', 'x')], is_const=True,
is_virtual=True, is_pure_virtual=False)
AbstractXptoImpl.add_constructor([])
Word = mod.add_class('Word')
Word.add_instance_attribute('low', 'uint8_t', is_const=False)
Word.add_instance_attribute('high', 'uint8_t', is_const=False)
Word.add_instance_attribute('word', 'uint16_t', is_const=False)
Word.add_constructor([])
mod.add_function('matrix_sum_of_elements',
ReturnValue.new('float'),
[Parameter.new("float*", 'matrix', direction=Parameter.DIRECTION_IN, array_length=6)])
mod.add_function('matrix_identity_new',
ReturnValue.new('void'),
[Parameter.new("float*", 'matrix', direction=Parameter.DIRECTION_OUT, array_length=6)])
top_ns = mod.add_cpp_namespace('TopNs')
outer_base = top_ns.add_class('OuterBase')
bottom_ns = top_ns.add_cpp_namespace('PrefixBottomNs')
inner = bottom_ns.add_class('PrefixInner',parent=outer_base)
inner.add_constructor([])
inner.add_method('Do', 'void', [])
Socket = mod.add_class('Socket', allow_subclassing=True)
Socket.add_constructor([])
Socket.add_method('Bind', ReturnValue.new('int'), [], is_virtual=True)
Socket.add_method('Bind', ReturnValue.new('int'), [Parameter.new('int', 'address')], is_virtual=True)
UdpSocket = mod.add_class('UdpSocket', parent=Socket)
UdpSocket.add_constructor([])
UdpSocket.add_method('Bind', ReturnValue.new('int'), [], is_virtual=True)
simple_struct_t = mod.add_struct('simple_struct_t')
simple_struct_t.add_instance_attribute('xpto', 'int')
# containers...
mod.add_container('SimpleStructList', ReturnValue.new('simple_struct_t'), 'list')
mod.add_function('get_simple_list', ReturnValue.new('SimpleStructList'), [])
mod.add_function('set_simple_list', 'int', [Parameter.new('SimpleStructList', 'list')])
mod.add_container('std::set<float>', 'float', 'set')
TestContainer = mod.add_class('TestContainer', allow_subclassing=True)
TestContainer.add_constructor([])
TestContainer.add_instance_attribute('m_floatSet', 'std::set<float>')
TestContainer.add_method('get_simple_list', ReturnValue.new('SimpleStructList'), [], is_virtual=True)
TestContainer.add_method('set_simple_list', 'int', [Parameter.new('SimpleStructList', 'list')], is_virtual=True)
TestContainer.add_method('set_simple_list_by_ref', 'int', [Parameter.new('SimpleStructList&', 'inout_list',
direction=Parameter.DIRECTION_INOUT)],
is_virtual=True)
mod.add_container('std::vector<simple_struct_t>', ReturnValue.new('simple_struct_t'), 'vector')
TestContainer.add_method('get_simple_vec', ReturnValue.new('std::vector<simple_struct_t>'), [], is_virtual=True)
TestContainer.add_method('set_simple_vec', 'int', [Parameter.new('std::vector<simple_struct_t>', 'vec')], is_virtual=True)
mod.add_container('std::vector<std::string>', 'std::string', 'vector')
TestContainer.add_method('get_vec', 'void', [Parameter.new('std::vector<std::string> &', 'outVec',
direction=Parameter.DIRECTION_OUT)])
TestContainer.add_method('set_vec_ptr', 'void', [Parameter.new('std::vector<std::string>*', 'inVec',
direction=Parameter.DIRECTION_IN, transfer_ownership=True)])
TestContainer.add_method('get_vec_ptr', 'void', [Parameter.new('std::vector<std::string>*', 'outVec',
direction=Parameter.DIRECTION_OUT)])
mod.add_container('std::map<std::string, simple_struct_t>',
(ReturnValue.new('std::string'), ReturnValue.new('simple_struct_t')),
'map')
TestContainer.add_method('get_simple_map', ReturnValue.new('std::map<std::string, simple_struct_t>'), [], is_virtual=True)
TestContainer.add_method('set_simple_map', 'int', [Parameter.new('std::map<std::string, simple_struct_t>', 'map')], is_virtual=True)
Tupl = mod.add_class('Tupl')
Tupl.add_binary_comparison_operator('<')
Tupl.add_binary_comparison_operator('<=')
Tupl.add_binary_comparison_operator('>=')
Tupl.add_binary_comparison_operator('>')
Tupl.add_binary_comparison_operator('==')
Tupl.add_binary_comparison_operator('!=')
Tupl.add_binary_numeric_operator('+')
Tupl.add_binary_numeric_operator('-')
Tupl.add_binary_numeric_operator('*')
Tupl.add_binary_numeric_operator('/')
Tupl.add_instance_attribute('x', 'int', is_const=False)
Tupl.add_instance_attribute('y', 'int', is_const=False)
Tupl.add_constructor([Parameter.new('Tupl const &', 'arg0')])
Tupl.add_constructor([])
Tupl.add_inplace_numeric_operator('+=')
Tupl.add_inplace_numeric_operator('-=')
Tupl.add_inplace_numeric_operator('*=')
Tupl.add_inplace_numeric_operator('/=')
Tupl.add_unary_numeric_operator('-')
Tupl.add_inplace_numeric_operator('+=', right='int')
ManipulatedObject = mod.add_class('ManipulatedObject')
ManipulatedObject.add_constructor([])
ManipulatedObject.add_method('GetValue', 'int', [], is_const=True)
ManipulatedObject.add_method('SetValue', 'void', [Parameter.new('int', 'value')])
ReferenceManipulator = mod.add_class('ReferenceManipulator', allow_subclassing=True)
ReferenceManipulator.add_constructor([])
ReferenceManipulator.add_method('manipulate_object', 'int', [])
ReferenceManipulator.add_method('do_manipulate_object', 'void',
[Parameter.new('ManipulatedObject&', 'obj', direction=Parameter.DIRECTION_INOUT)],
is_virtual=True, is_pure_virtual=True)
VectorLike = mod.add_class('VectorLike')
VectorLike.add_constructor([])
VectorLike.add_method('get_len', 'size_t', [], custom_name='__len__')
VectorLike.add_method('add_VectorLike', 'VectorLike', [Parameter.new('VectorLike', 'rhs')], custom_name='__add__')
VectorLike.add_method('iadd_VectorLike', 'VectorLike', [Parameter.new('VectorLike', 'rhs')], custom_name='__iadd__')
VectorLike.add_method('mul_VectorLike', 'VectorLike', [Parameter.new('unsigned int', 'n')], custom_name='__mul__')
VectorLike.add_method('imul_VectorLike', 'VectorLike', [Parameter.new('unsigned int', 'n')], custom_name='__imul__')
VectorLike.add_method('set_item', 'int', [Parameter.new('int', 'index'), Parameter.new('double', 'value')],
custom_name='__setitem__')
VectorLike.add_method('get_item', 'double', [Parameter.new('int', 'index')], custom_name='__getitem__')
VectorLike.add_method('set_slice', 'int', [Parameter.new('int', 'index1'),
Parameter.new('int', 'index2'),
Parameter.new('VectorLike', 'values')], custom_name='__setslice__')
VectorLike.add_method('get_slice', 'VectorLike', [Parameter.new('int', 'index1'),
Parameter.new('int', 'index2')], custom_name='__getslice__')
VectorLike.add_method('contains_value', 'int', [Parameter.new('double', 'value')], custom_name='__contains__')
VectorLike.add_method('append', 'void', [Parameter.new('double', 'value')])
VectorLike2 = mod.add_class('VectorLike2')
VectorLike2.add_constructor([])
VectorLike2.add_method('append', 'void', [Parameter.new('double', 'value')])
MapLike = mod.add_class('MapLike')
MapLike.add_constructor([])
MapLike.add_method('set', 'void', [Parameter.new('int', 'key'), Parameter.new('double', 'value')])
Error = mod.add_exception('Error')
DomainError = mod.add_exception('DomainError', parent=Error)
mod.add_function('my_inverse_func', 'double', [Parameter.new('double', 'x')],
throw=[DomainError])
ClassThatThrows = mod.add_class('ClassThatThrows', allow_subclassing=True)
ClassThatThrows.add_constructor([Parameter.new('double', 'x')], throw=[DomainError])
ClassThatThrows.add_method('my_inverse_method', 'double', [Parameter.new('double', 'x')],
throw=[DomainError])
std_exception = mod.add_exception('exception', foreign_cpp_namespace='std', message_rvalue='%(EXC)s.what()')
mod.add_function('my_inverse_func2', 'double', [Parameter.new('double', 'x')],
throw=[std_exception])
ClassThatThrows.add_method('my_inverse_method2', 'double', [Parameter.new('double', 'x')],
throw=[std_exception])
mod.add_function('my_inverse_func3', 'double', [Parameter.new('double', 'x')],
throw=[std_exception])
ClassThatThrows.add_method('my_inverse_method3', 'double', [Parameter.new('double', 'x')],
throw=[std_exception])
ClassThatThrows.add_method('throw_error', 'int', [], throw=[std_exception], is_const=True, is_virtual=True)
# https://bugs.launchpad.net/pybindgen/+bug/450255
ProtectedConstructor = mod.add_class('ProtectedConstructor')
ProtectedConstructor.add_constructor([])
ProtectedConstructor.add_constructor([Parameter.new('ProtectedConstructor&', 'c')], visibility='protected')
# https://bugs.launchpad.net/pybindgen/+bug/455689
property_std_string = mod.add_struct('property', template_parameters=['std::string'])
Box = mod.add_class('Box')
Box.add_constructor([])
Box.add_static_attribute('instance_count', ReturnValue.new('int'))
Box.add_method('getFoobarInternalPtr', ReturnValue.new('const Foobar*', reference_existing_object=True), [])
Box.add_method('getFoobarInternalRef', ReturnValue.new('Foobar&', reference_existing_object=True), [])
Box.add_method('getFoobarInternalPtr2', ReturnValue.new('Foobar*', return_internal_reference=True), [])
Box.add_method('getFoobarInternalRef2', ReturnValue.new('Foobar&', return_internal_reference=True), [])
Box.add_instance_attribute('m_internalFoobar', ReturnValue.new('Foobar*', reference_existing_object=True))
# multiple inheritance
MIRoot = mod.add_class('MIRoot')
MIRoot.add_constructor([])
MIRoot.add_method('root_method', 'int', [], is_const=True)
MIBase1 = mod.add_class('MIBase1', parent=MIRoot)
MIBase1.add_constructor([])
MIBase1.add_method('base1_method', 'int', [], is_const=True)
MIBase2 = mod.add_class('MIBase2', parent=MIRoot)
MIBase2.add_constructor([])
MIBase2.add_method('base2_method', 'int', [], is_const=True)
MIMixed = mod.add_class('MIMixed', parent=[MIBase1, MIBase2])
MIMixed.add_constructor([])
MIMixed.add_method('mixed_method', 'int', [], is_const=True)
mod.add_function('my_throwing_func', 'Tupl', [], throw=[std_exception])
IFoo = mod.add_class("IFoo", destructor_visibility='protected', allow_subclassing=True)
IFoo.add_method("DoSomething", None, [], is_pure_virtual=True)
IFooImpl = mod.add_class("IFooImpl", parent=IFoo, destructor_visibility='public')
IFooImpl.add_constructor([])
IFooImpl.add_method("DoSomething", None, [], is_virtual=True)
mod.add_function("test_args_kwargs", "int", [param("const char *", "args"), param("const char *", "kwargs")])
#### --- error handler ---
class MyErrorHandler(pybindgen.settings.ErrorHandler):
def __init__(self):
super(MyErrorHandler, self).__init__()
self.num_errors = 0
def handle_error(self, wrapper, exception, traceback_):
print >> sys.stderr, "exception %s in wrapper %s" % (exception, wrapper)
self.num_errors += 1
if 0: # verbose?
import traceback
traceback.print_tb(traceback_)
return True
pybindgen.settings.error_handler = MyErrorHandler()
foomodulegen_common.customize_module(mod)
## ---- finally, generate the whole thing ----
mod.generate(FileCodeSink(out_file))
def register_functions(root_module):
module = root_module
module.add_function(
'tr_sessionLoadSettings',
typedefs.ErrorCheckReturn('bool',
exception='PyExc_ValueError',
error_string='"unable to load settings"',
error_cleanup='Py_DECREF(py_dictionary);\n'),
[
typedefs.BencOutParam('BencDict *', 'dictionary'),
param('char *', 'config_dir', default_value='NULL'),
param('char *', 'app_name', default_value='(char*)"Transmission"')
],
custom_name='user_settings',
docstring=
"Load settings from the configuration directory's settings.json file "
"using Transmission's default settings as fallbacks for missing keys\\n\\n"
"Args:\\n"
" config_dir (str): configuration directory or None\\n"
" app_name (str): used to find default configuration directory if "
"config_dir is None\\n"
"Returns:\\n"
" (BencDict) user settings")
module.add_function('tr_sessionGetDefaultSettings',
'void',
[typedefs.BencOutParam('BencDict *', 'dictionary')],
custom_name='default_settings',
docstring="Get Transmission's default settings\\n\\n"
"Returns:\\n"
" (BencDict) default settings")
module.add_function(
'tr_getDefaultConfigDir',
'char const *',
[param('char const *', 'app_name', default_value='"Transmission"')],
custom_name='default_config_dir',
docstring="Get the default configuration directory\\n\\n"
"Returns:\\n"
" (str) default configuration directory")
module.add_function('tr_getDefaultDownloadDir',
'char const *', [],
custom_name='default_download_dir',
docstring="Get the default download directory\\n\\n"
"Returns:\\n"
" (str) default download directory")
module.add_function('tr_getMessageQueuing',
'bool', [],
custom_name='message_queuing_enabled',
docstring="Check if message queuing is enabled\\n\\n"
"Returns:\\n"
" (bool) queuing is enabled")
module.add_function(
'tr_setMessageQueuing',
'void', [param('bool', 'enabled')],
custom_name='message_queuing_set',
docstring=
"If enabled logging messages will be queued instead of going to stderr\\n\\n"
"Args:\\n"
" enabled (bool): turn on/off message queuing\\n")
module.add_function('tr_getQueuedMessages',
ReturnValue.new('tr_msg_list *',
caller_owns_return=True), [],
custom_name='queued_messages',
docstring="Retrieve a list of queued messaged\\n\\n"
"Returns:\\n"
" (list) logged messages")
module.add_function('tr_torrentsQueueMoveUp',
'void', [typedefs.ListParam('Torrent', 'torrents')],
custom_name='queue_move_up',
docstring="Move Torrents up in download queue\\n\\n"
"Args:\\n"
" torrents (list): Torrents to move\\n")
module.add_function('tr_torrentsQueueMoveDown',
'void', [typedefs.ListParam('Torrent', 'torrents')],
custom_name='queue_move_down',
docstring="Move Torrents down in download queue\\n\\n"
"Args:\\n"
" torrents (list): Torrents to move\\n")
module.add_function(
'tr_torrentsQueueMoveTop',
'void', [typedefs.ListParam('Torrent', 'torrents')],
custom_name='queue_move_top',
docstring="Move Torrents to top of download queue\\n\\n"
"Args:\\n"
" torrents (list): Torrents to move\\n")
module.add_function(
'tr_torrentsQueueMoveBottom',
'void', [typedefs.ListParam('Torrent', 'torrents')],
custom_name='queue_move_bottom',
docstring="Move Torrents to bottom of download queue\\n\\n"
"Args:\\n"
" torrents (list): Torrents to move\\n")
submodule = SubModule(
'formatter',
parent=module,
docstring=
"Utility functions for setting the unit formatting strings for printing"
)
submodule.add_function(
'tr_formatter_mem_init',
'void', [
param('unsigned int', 'kilo', default_value='1000'),
param('const char *', 'kb', default_value='"KiB"'),
param('const char *', 'mb', default_value='"MiB"'),
param('const char *', 'gb', default_value='"GiB"'),
param('const char *', 'tb', default_value='"TiB"')
],
custom_name='memory_units',
docstring=
"Set the multiplier and formatting strings for memory units\\n\\n"
"Args:\\n"
" kilo (int): Thousands multiplier\\n"
" kb (str): Kilobytes string representation\\n"
" mb (str): Megabytes string representation\\n"
" gb (str): Gigabytes string representation\\n"
" tb (str): Terabytes string representation\\n")
submodule.add_function(
'tr_formatter_size_init',
'void', [
param('unsigned int', 'kilo'),
param('const char *', 'kb'),
param('const char *', 'mb'),
param('const char *', 'gb'),
param('const char *', 'tb')
],
custom_name='size_units',
docstring=
"Set the multiplier and formatting strings for file size units\\n\\n"
"Args:\\n"
" kilo (int): Thousands multiplier\\n"
" kb (str): Kilobytes string representation\\n"
" mb (str): Megabytes string representation\\n"
" gb (str): Gigabytes string representation\\n"
" tb (str): Terabytes string representation\\n")
submodule.add_function(
'tr_formatter_speed_init',
'void', [
param('unsigned int', 'kilo'),
param('const char *', 'kb'),
param('const char *', 'mb'),
param('const char *', 'gb'),
param('const char *', 'tb')
],
custom_name='speed_units',
docstring=
"Set the multiplier and formatting strings for network speed units\\n\\n"
"Args:\\n"
" kilo (int): Thousands multiplier\\n"
" kb (str): Kilobytes string representation\\n"
" mb (str): Megabytes string representation\\n"
" gb (str): Gigabytes string representation\\n"
" tb (str): Terabytes string representation\\n")
return
