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_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