def bind_test(gen): gen.start('my_test') lib.bind_defaults(gen) # inject test code in the wrapper gen.insert_code( '''\ enum GlobalEnum { GE_a, GE_b, GE_c = 8 }; struct Type { enum StructEnum { SE_a, SE_b = 128, SE_c = 512 }; }; enum TypedEnum : int16_t { TE_a, TE_b, TE_c = 16384 }; enum NamedEnum { NE_a, NE_b, NE_c = 4096 }; ''', True, False) gen.bind_named_enum('GlobalEnum', ['GE_a', 'GE_b', 'GE_c']) gen.bind_named_enum('Type::StructEnum', ['SE_a', 'SE_b', 'SE_c']) gen.bind_named_enum('TypedEnum', ['TE_a', 'TE_b', 'TE_c'], storage_type='int16_t') gen.bind_named_enum('NamedEnum', ['NE_a', 'NE_b', 'NE_c']) gen.finalize() return gen.get_output()
def bind_test(gen): gen.start('my_test') gen.add_include('memory', True) lib.bind_defaults(gen) # inject test code in the wrapper gen.insert_code( '''\ std::shared_ptr<int> obj0(new int(2)), obj1(new int(3)), obj2(obj0); std::shared_ptr<int> &get_obj0() { return obj0; } std::shared_ptr<int> &get_obj1() { return obj1; } std::shared_ptr<int> &get_obj2() { return obj2; } ''', True, False) shared_ptr_int_conv = gen.begin_class( 'std::shared_ptr<int>', bound_name='sint', features={'proxy': SharedPtrProxyFeature(gen.get_conv('int'))}) gen.end_class(shared_ptr_int_conv) gen.bind_function('get_obj0', 'std::shared_ptr<int> &', []) gen.bind_function('get_obj1', 'std::shared_ptr<int> &', []) gen.bind_function('get_obj2', 'std::shared_ptr<int> &', []) gen.finalize() return gen.get_output()
def bind_test(gen): gen.start('my_test') lib.bind_defaults(gen) # inject test code in the wrapper gen.insert_code( '''\ struct base_class { int base_method() { return 4; } int base_method_override() { return 4; } virtual int virtual_method() { return 6; } int u{6}; static int v; int override{4}; static int static_override; }; int base_class::v{7}; int base_class::static_override{1}; struct derived_class : base_class { int derived_method() { return 8; } int base_method_override() { return 8; } int virtual_method() override { return 9; } int override{12}; static int static_override; }; int derived_class::static_override{42}; int read_virtual_method_through_base_class(base_class &o) { return o.virtual_method(); } ''', True, False) base_conv = gen.begin_class('base_class') gen.bind_constructor(base_conv, []) gen.bind_method(base_conv, 'base_method', 'int', []) gen.bind_method(base_conv, 'base_method_override', 'int', []) gen.bind_method(base_conv, 'virtual_method', 'int', []) gen.bind_members(base_conv, ['int u', 'int override']) gen.bind_static_members(base_conv, ['int v', 'int static_override']) gen.end_class(base_conv) derived_conv = gen.begin_class('derived_class') gen.add_base(derived_conv, base_conv) gen.bind_constructor(derived_conv, []) gen.bind_method(derived_conv, 'derived_method', 'int', []) gen.bind_method(derived_conv, 'base_method_override', 'int', []) gen.bind_members(derived_conv, ['int override']) gen.bind_static_members(derived_conv, ['int static_override']) gen.end_class(derived_conv) gen.bind_function('read_virtual_method_through_base_class', 'int', ['base_class &o']) gen.finalize() return gen.get_output()
def bind_test(gen): gen.start('my_test') lib.bind_defaults(gen) # inject test code in the wrapper gen.insert_code('''\ template <typename T> struct enclosing_template { struct nested_struct { int v{9}; }; nested_struct n; }; template <typename T> auto &GetNestedStruct(enclosing_template<T> &s) { return s.n; } ''', True, False) nested_struct = gen.begin_class('enclosing_template<int>::nested_struct', bound_name='nested_struct_int') gen.bind_constructor(nested_struct, []) gen.bind_member(nested_struct, 'int v') gen.end_class(nested_struct) enclosing_struct = gen.begin_class('enclosing_template<int>', bound_name='enclosing_template_int') gen.bind_constructor(enclosing_struct, []) gen.bind_member(enclosing_struct, 'enclosing_template<int>::nested_struct n') gen.end_class(enclosing_struct) gen.bind_function('GetNestedStruct<int>', 'enclosing_template<int>::nested_struct &', ['enclosing_template<int> &s'], bound_name='GetNestedStructInt') gen.finalize() return gen.get_output()
def bind_test(gen): gen.start('my_test') lib.bind_defaults(gen) # inject test code in the wrapper gen.insert_code( '''\ struct nested_struct { int v{8}; }; struct enclosing_struct { nested_struct n; }; ''', True, False) nested_struct = gen.begin_class('nested_struct') gen.bind_constructor(nested_struct, []) gen.bind_member(nested_struct, 'int v') gen.end_class(nested_struct) enclosing_struct = gen.begin_class('enclosing_struct') gen.bind_constructor(enclosing_struct, []) gen.bind_member(enclosing_struct, 'nested_struct n') gen.end_class(enclosing_struct) gen.finalize() return gen.get_output()
def bind_test(gen): gen.start('my_test') lib.bind_defaults(gen) # inject test code in the wrapper gen.insert_code('''\ struct simple_struct { int v{3}; static int i; static const char *s; }; int simple_struct::i = 5; const char *simple_struct::s = "some string"; ''', True, False) simple_struct = gen.begin_class('simple_struct') gen.bind_constructor(simple_struct, []) gen.bind_member(simple_struct, 'int v') gen.bind_static_member(simple_struct, 'int i') gen.bind_static_member(simple_struct, 'const char *s') gen.end_class(simple_struct) gen.finalize() return gen.get_output()
def bind_test(gen): gen.start('my_test') lib.bind_defaults(gen) # inject test code in the wrapper gen.insert_code( '''\ int v{2}; struct simple_struct { int v{4}; }; simple_struct s; namespace ns { int v{14}; float u{7.f}; } ''', True, False) simple_struct = gen.begin_class('simple_struct') gen.bind_member(simple_struct, 'int v') gen.end_class(simple_struct) gen.bind_variables(['int v', 'simple_struct s']) gen.bind_variable('int ns::v', bound_name='w') gen.bind_variable('float ns::u') gen.finalize() return gen.get_output()
def bind_test(gen): gen.start('my_test') lib.bind_defaults(gen) gen.insert_code(''' struct A { int v{2}; }; void modify_in_out_struct(A *a) { a->v = 3; } ''') A = gen.begin_class('A') gen.bind_constructor(A, []) gen.bind_member(A, 'int v') gen.end_class(A) gen.bind_function('modify_in_out_struct', 'void', ['A *a'], {'arg_in_out': ['a']}) gen.insert_code('void out_values_function_call(int &a, int d, int *b, float k) { a = 8 * d; *b = 14 * k; }\n\n') gen.bind_function('out_values_function_call', 'void', ['int &a', 'int d', 'int *b', 'float k'], {'arg_out': ['a', 'b']}) gen.insert_code('int out_values_function_call_rval(int &a, int d, int *b, float k = 1) { a = 8 * d; *b = 14 * d; return d*k; }\n\n') gen.bind_function_overloads('out_values_function_call_rval', [ ('int', ['int &a', 'int d', 'int *b'], {'arg_out': ['a', 'b']}), ('int', ['int &a', 'int d', 'int *b', 'float k'], {'arg_out': ['a', 'b']}) ]) gen.insert_code('bool in_out_value(int *in_out) { *in_out = *in_out * 4; return true; }') gen.bind_function('in_out_value', 'bool', ['int *in_out'], {'arg_in_out': ['in_out']}) gen.finalize() return gen.get_output()
def bind_test(gen): gen.start('my_test') lib.bind_defaults(gen) # inject test code in the wrapper gen.insert_code('''\ struct simple_struct { simple_struct() : a(7), b(17.5f), c(true), d(9), text_field("some content") {} int a; float b; bool c; const int d; const char *text_field; }; static simple_struct return_instance; simple_struct *return_simple_struct_by_pointer() { return &return_instance; } ''', True, False) simple_struct = gen.begin_class('simple_struct') gen.bind_members(simple_struct, ['const char *text_field', 'int a', 'float b', 'bool c', 'const int d']) gen.end_class(simple_struct) gen.bind_function('return_simple_struct_by_pointer', 'simple_struct*', []) gen.finalize() return gen.get_output()
def bind_test(gen): gen.start('my_test') lib.bind_defaults(gen) # inject test code in the wrapper gen.insert_code( '''\ #include <functional> static std::function<void()> simple_void_function; void SetSimpleVoidFunction(std::function<void()> f) { simple_void_function = f; } void InvokeSimpleVoidFunction() { simple_void_function(); } static std::function<int(int, int &, int *)> compute_function; void SetComputeFunction(std::function<int(int, int &, int *)> f) { compute_function = f; } int InvokeComputeFunction(int v, int m, int c) { return compute_function(v, m, &c); } ''', True, False) lib.stl.bind_function_T(gen, 'std::function<void()>', 'VoidCb') gen.bind_function('SetSimpleVoidFunction', 'void', ['std::function<void()> f']) gen.bind_function('InvokeSimpleVoidFunction', 'void', []) lib.stl.bind_function_T(gen, 'std::function<int(int, int &, int *)>') gen.bind_function('SetComputeFunction', 'void', ['std::function<int(int, int &, int *)> f']) gen.bind_function('InvokeComputeFunction', 'int', ['int v', 'int m', 'int c']) gen.finalize() return gen.get_output()
def bind_test(gen): gen.start('my_test') lib.bind_defaults(gen) # inject test code in the wrapper gen.insert_code('''\ #include <future> #include <thread> #include <chrono> static std::future<int> f; void SetBarrierValue(std::promise<int> barrier) { std::this_thread::sleep_for(std::chrono::seconds(3)); barrier.set_value(8); } std::thread work_thread; std::future<int> GetFutureValue() { std::promise<int> barrier; std::future<int> future = barrier.get_future(); work_thread = std::thread(SetBarrierValue, std::move(barrier)); return std::move(future); } ''', True, False) lib.stl.bind_future_T(gen, 'int', 'FutureInt') gen.bind_function('GetFutureValue', 'std::future<int>', []) gen.add_custom_free_code('work_thread.join();\n') gen.finalize() return gen.get_output()
def bind_test(gen): gen.start('my_test') lib.bind_defaults(gen) # inject test code in the wrapper gen.insert_code('''\ struct simple_struct { simple_struct(int _v) : v(_v) {} simple_struct operator-(const simple_struct &b) { return simple_struct(v - b.v); } simple_struct operator+(const simple_struct &b) { return simple_struct(v + b.v); } simple_struct operator/(const simple_struct &b) { return simple_struct(v / b.v); } simple_struct operator*(const simple_struct &b) { return simple_struct(v * b.v); } simple_struct operator+(int k) { return simple_struct(v + k); } simple_struct operator/(int k) { return simple_struct(v / k); } simple_struct operator*(int k) { return simple_struct(v * k); } simple_struct operator-(int k) { return simple_struct(v - k); } void operator-=(const simple_struct &b) { v -= b.v; } void operator+=(const simple_struct &b) { v += b.v; } void operator/=(const simple_struct &b) { v /= b.v; } void operator*=(const simple_struct &b) { v *= b.v; } void operator-=(int k) { v -= k; } void operator+=(int k) { v += k; } void operator/=(int k) { v /= k; } void operator*=(int k) { v *= k; } bool operator==(int k) const { return k == v; } bool operator==(const simple_struct &b) const { return b.v == v; } bool operator!=(int k) const { return k != v; } bool operator!=(const simple_struct &b) const { return b.v != v; } int v; }; ''', True, False) simple_struct = gen.begin_class('simple_struct') gen.bind_constructor(simple_struct, ['int v']) gen.bind_arithmetic_ops_overloads(simple_struct, ['-', '+', '/', '*'], [ ('simple_struct', ['simple_struct b'], {"bound_name": "SimpleStruct"}), ('simple_struct', ['int k'], {"bound_name": "Int"}) ]) gen.bind_inplace_arithmetic_ops_overloads(simple_struct, ['-=', '+=', '/=', '*='], [ (['simple_struct b'], {"bound_name": "SimpleStruct"}), (['int k'], {"bound_name": "Int"}) ]) gen.bind_comparison_ops_overloads(simple_struct, ['==', '!='], [ (['simple_struct b'], []), (['int k'], []) ]) gen.bind_member(simple_struct, 'int v') gen.end_class(simple_struct) gen.finalize() return gen.get_output()
def bind_test(gen): gen.start('my_test') lib.bind_defaults(gen) gen.insert_code(''' int *return_nullptr() { return nullptr; } ''') gen.bind_function('return_nullptr', 'int *', []) gen.finalize() return gen.get_output()
def bind_test(gen): gen.start('my_test') lib.bind_defaults(gen) gen.bind_extern_type('SomeExternType') gen.bind_extern_type( 'nspace::SomeOtherExternType', 'BoundAsThis' ) # mostly for documentation purpose (so that extern types display the proper bound name) gen.bind_extern_type( 'nspace::YetAnotherExternType', 'WithThisBoundName', 'TheModule' ) # mostly for documentation purpose (so that extern types display the proper bound name) gen.finalize() return gen.get_output()
def bind_test(gen): gen.start('my_test') lib.bind_defaults(gen) # inject test code in the wrapper gen.insert_code('''\ template <typename T> T get() { return T(8); } ''', True, False) gen.bind_function('get<int>', 'int', [], bound_name='get_int') gen.bind_function('get<float>', 'float', [], bound_name='get_float') gen.finalize() return gen.get_output()
def bind_test(gen): gen.start('my_test') lib.bind_defaults(gen) # inject test code in the wrapper gen.insert_code( '''\ struct simple_struct { simple_struct() : v(7) {} int v; }; static simple_struct return_instance; simple_struct return_simple_struct_by_value() { return return_instance; } simple_struct *return_simple_struct_by_pointer() { return &return_instance; } simple_struct &return_simple_struct_by_ref() { return return_instance; } static simple_struct take_instance; void take_simple_struct_by_value(simple_struct v) { take_instance.v = -7; take_instance = v; } void take_simple_struct_by_pointer(simple_struct *v) { take_instance.v = -7; take_instance = *v; } void take_simple_struct_by_ref(simple_struct &v) { take_instance.v = -7; take_instance = v; } bool test_simple_struct() { return take_instance.v == return_instance.v; } ''', True, False) simple_struct = gen.begin_class('simple_struct') gen.end_class(simple_struct) gen.bind_function('return_simple_struct_by_value', 'simple_struct', []) gen.bind_function('return_simple_struct_by_pointer', 'simple_struct*', []) gen.bind_function('return_simple_struct_by_ref', 'simple_struct&', []) gen.bind_function('take_simple_struct_by_value', 'void', ['simple_struct s']) gen.bind_function('take_simple_struct_by_pointer', 'void', ['simple_struct *s']) gen.bind_function('take_simple_struct_by_ref', 'void', ['simple_struct &s']) gen.bind_function('test_simple_struct', 'bool', []) gen.finalize() return gen.get_output()
def bind_test(gen): gen.start('my_test') lib.bind_defaults(gen) # inject test code in the wrapper gen.insert_binding_code('''\ int get_int() { throw 0; return 8; } ''') gen.bind_function('get_int', 'int', [], {'exception': 'native exception raised'}) gen.finalize() return gen.get_output()
def bind_test(gen): gen.start('my_test') lib.bind_defaults(gen) # inject test code in the wrapper gen.insert_code( '''\ struct simple_struct { simple_struct() = default; simple_struct(float k) : u(k), v(10 * int(k)) {} float u = 4.f; int v = 7; }; std::shared_ptr<simple_struct> get_shared_ptr_to_simple_struct() { return std::make_shared<simple_struct>(); } std::shared_ptr<simple_struct> get_empty_shared_ptr() { return {}; } ''', True, False) gen.add_include('memory', True) simple_struct_conv = gen.begin_class('simple_struct') gen.bind_members(simple_struct_conv, ['float u', 'int v']) gen.end_class(simple_struct_conv) shared_ptr_simple_struct_conv = gen.begin_class( 'std::shared_ptr<simple_struct>', bound_name='ssimple_struct', features={'proxy': SharedPtrProxyFeature(simple_struct_conv)}) gen.bind_constructor(shared_ptr_simple_struct_conv, ['float k'], ['proxy']) gen.bind_members(shared_ptr_simple_struct_conv, ['float u', 'int v'], ['proxy']) gen.end_class(shared_ptr_simple_struct_conv) gen.bind_function('get_shared_ptr_to_simple_struct', 'std::shared_ptr<simple_struct>', []) gen.bind_function('get_empty_shared_ptr', 'std::shared_ptr<simple_struct>', []) gen.finalize() return gen.get_output()
def bind_test(gen): gen.start('my_test') lib.bind_defaults(gen) # inject test code in the wrapper gen.insert_code('''\ struct SomeStruct {}; \n''', True, False) def get_repr(var_self, var_repr): return '%s = "repr!";\n' % var_repr some_struct = gen.begin_class('SomeStruct', features={'repr': get_repr}) gen.bind_constructor(some_struct, []) gen.end_class(some_struct) gen.finalize() return gen.get_output()
def bind_test(gen): gen.start('my_test') lib.bind_defaults(gen) # inject test code in the wrapper gen.insert_code('''\ int get_int() { return 8; } int get() { return 0; } int get(int v) { return v / 2; } int get(int v, int k) { return v * k; } int get(int v, int k, int b) { return v * k + b; } static int global_int = 0; void set_global_int() { global_int = 8; } int get_global_int() { return global_int; } int get_global_int_multiplied(int k = 5) { return 3 * k; } void get_modify_arg_in_out(int &v, int k=5) { v = 3 * k + v; } ''', True, False) gen.bind_function('get_int', 'int', []) gen.bind_function_overloads('get', [ ('int', [], []), ('int', ['int v'], []), ('int', ['int v', 'int k'], []), ('int', ['int v', 'int k', 'int b'], []) ]) gen.bind_function('set_global_int', 'void', []) gen.bind_function('get_global_int', 'int', []) gen.bind_function('get_global_int_multiplied', 'int', ['?int k']) gen.bind_function('get_modify_arg_in_out', 'void', ['int &v', '?int k'], {'arg_in_out': ['v']}) gen.finalize() return gen.get_output()
def bind_test(gen): gen.start('my_test') lib.bind_defaults(gen) # inject test code in the wrapper gen.insert_code( '''\ struct simple_struct { simple_struct() : v_(-8) {} simple_struct(int v) : v_(v) {} int v_; }; ''', True, False) simple_struct = gen.begin_class('simple_struct') gen.bind_constructor_overloads(simple_struct, [([], []), (['int v_'], [])]) gen.bind_member(simple_struct, 'int v_') gen.end_class(simple_struct) gen.finalize() return gen.get_output()
def bind_test(gen): gen.start('my_test') lib.bind_defaults(gen) gen.insert_code(''' struct Object { int a{11}; }; int ObjectGet(Object *o, int v) { return o->a + v; } \n''') obj = gen.begin_class('Object') def route_function(args): return 'ObjectGet(%s);' % (', '.join(args)) gen.bind_constructor(obj, []) gen.bind_method(obj, 'Get', 'int', ['int v'], {'route': route_function}) gen.end_class(obj) gen.finalize() return gen.get_output()
def bind_test(gen): gen.start('my_test') lib.bind_defaults(gen) # inject test code in the wrapper gen.insert_code('''\ struct simple_struct { simple_struct() : a(3), b(11), c(1) {} unsigned int a:2; unsigned int b:4; unsigned int c:2; }; ''', True, False) simple_struct = gen.begin_class('simple_struct') gen.bind_constructor(simple_struct, []) gen.bind_members(simple_struct, ['int a:', 'int b:', 'int c:']) gen.end_class(simple_struct) gen.finalize() return gen.get_output()
def bind_test(gen): gen.start('my_test') lib.bind_defaults(gen) # inject test code in the wrapper gen.insert_code( '''\ // basic interoperability int return_int() { return 8; } float return_float() { return 8.f; } const char *return_const_char_ptr() { return "const char * -> string"; } static int static_int = 9; int *return_int_by_pointer() { return &static_int; } int &return_int_by_reference() { return static_int; } // argument passing int add_int_by_value(int a, int b) { return a + b; } int add_int_by_pointer(int *a, int *b) { return *a + *b; } int add_int_by_reference(int &a, int &b) { return a + b; } \n''', True, False) gen.add_include('string', True) gen.bind_function('return_int', 'int', []) gen.bind_function('return_float', 'float', []) gen.bind_function('return_const_char_ptr', 'const char *', []) gen.bind_function('return_int_by_pointer', 'int*', []) gen.bind_function('return_int_by_reference', 'int&', []) gen.bind_function('add_int_by_value', 'int', ['int a', 'int b']) gen.bind_function('add_int_by_pointer', 'int', ['int *a', 'int *b']) gen.bind_function('add_int_by_reference', 'int', ['int &a', 'int &b']) gen.finalize() return gen.get_output()
def bind_test(gen): gen.start('my_test') lib.bind_defaults(gen) # inject test code in the wrapper gen.insert_code( '''\ struct simple_struct { simple_struct() : a(1) {} int set_a(int v) { return a = v; } bool set_a(int v0, int v1) { a = v0 + v1; return true; } int get_a() { return a; } static int get_static_int() { return 4; } int a; }; ''', True, False) simple_struct = gen.begin_class('simple_struct') gen.bind_constructor(simple_struct, []) gen.bind_method_overloads(simple_struct, 'set_a', [('int', ['int v'], []), ('bool', ['int v0', 'int v1'], [])]) gen.bind_method(simple_struct, 'get_a', 'int', []) gen.bind_static_method(simple_struct, 'get_static_int', 'int', []) gen.end_class(simple_struct) gen.finalize() return gen.get_output()
def bind_test(gen): gen.start('my_test') lib.bind_defaults(gen) # inject test code in the wrapper gen.insert_code( '''\ struct base_class { }; struct derived_class : base_class { int u{7}; }; static derived_class __b; static base_class &GetBaseClass() { return __b; } ''', True, False) base_conv = gen.begin_class('base_class') gen.bind_constructor(base_conv, []) gen.end_class(base_conv) derived_conv = gen.begin_class('derived_class') gen.add_base(derived_conv, base_conv) gen.bind_constructor(derived_conv, []) gen.bind_members(derived_conv, ['int u']) gen.end_class(derived_conv) gen.bind_function('GetBaseClass', 'base_class &', []) gen.finalize() return gen.get_output()
def bind_test(gen): gen.start('my_test') lib.bind_defaults(gen) # inject test code in the wrapper gen.insert_code( '''\ struct simple_struct {}; simple_struct obj0, obj1; simple_struct &get_obj0() { return obj0; } simple_struct &get_obj1() { return obj1; } ''', True, False) simple_struct = gen.begin_class('simple_struct') gen.end_class(simple_struct) gen.bind_function('get_obj0', 'simple_struct &', []) gen.bind_function('get_obj1', 'simple_struct &', []) gen.finalize() return gen.get_output()
def bind_test(gen): gen.start('my_test') lib.bind_defaults(gen) # inject test code in the wrapper gen.add_include('memory', True) gen.add_include('string', True) gen.insert_binding_code('''\ struct A { virtual std::string GetType() const = 0; int GetBaseValue() const { return 12; } }; struct B : A { std::string GetType() const override { return "B"; } int b{3}; }; struct C : A { std::string GetType() const override { return "C"; } int c{7}; }; static std::unique_ptr<A> b(new B); static std::unique_ptr<A> c(new C); A *get_b() { return b.get(); } A *get_c() { return c.get(); } ''') def A_rval_transform(gen, conv, expr, var_out, ownership): src = 'if ((%s)->GetType() == "C")\n' % expr src += gen.rval_from_c_ptr(gen.get_conv('C'), var_out, '((C*)%s)' % expr, ownership) src += 'else if ((%s)->GetType() == "B")\n' % expr src += gen.rval_from_c_ptr(gen.get_conv('B'), var_out, '((B*)%s)' % expr, ownership) src += 'else\n' src += gen.rval_from_c_ptr(conv, var_out, expr, ownership) return src A = gen.begin_class('A', noncopyable=True) A.add_feature('rval_transform', A_rval_transform) gen.bind_method(A, 'GetType', 'std::string', []) gen.bind_method(A, 'GetBaseValue', 'int', []) gen.end_class(A) B = gen.begin_class('B') gen.add_base(B, A) gen.bind_member(B, 'int b') gen.end_class(B) C = gen.begin_class('C') gen.add_base(C, A) gen.bind_member(C, 'int c') gen.end_class(C) gen.bind_function('get_b', 'A *', [], {}) gen.bind_function('get_c', 'A *', [], {}) gen.finalize() return gen.get_output()
def bind_test(gen): gen.start('my_test') lib.bind_defaults(gen) # inject test code in the wrapper gen.insert_code('''\ #include <iostream> int consume_pointer_to_int(const int *p) { std::cout << p[0] << std::endl; std::cout << p[1] << std::endl; return p[1]; } ''', True, False) int_ptr = gen.bind_ptr('int *', bound_name='IntPointer') int_conv = gen.get_conv('int') gen.add_include('vector', is_system=True) if gen.get_language() == 'CPython': gen.bind_type(lib.cpython.stl.PySequenceToStdVectorConverter('PySequenceOfInt', int_conv)) gen.bind_type(lib.cpython.stl.PySequenceToStdVectorConverter('PySequenceOfInt_ptr', int_ptr)) elif gen.get_language() == 'Lua': gen.bind_type(lib.lua.stl.LuaTableToStdVectorConverter('LuaTableOfInt', int_conv)) gen.bind_type(lib.lua.stl.LuaTableToStdVectorConverter('LuaTableOfInt_ptr', int_ptr)) std_vector_int = gen.begin_class('std::vector<int>', features={'sequence': lib.std.VectorSequenceFeature(int_conv)}) if gen.get_language() == 'CPython': gen.bind_constructor(std_vector_int, ['?PySequenceOfInt sequence']) elif gen.get_language() == 'Lua': gen.bind_constructor(std_vector_int, ['?LuaTableOfInt sequence']) gen.bind_method(std_vector_int, 'size', 'int', []) gen.bind_method(std_vector_int, 'push_back', 'void', ['int v']) gen.bind_method(std_vector_int, 'at', 'int&', ['int pos']) gen.bind_method(std_vector_int, 'data', 'int*', []) gen.end_class(std_vector_int) gen.bind_function('consume_pointer_to_int', 'int', ['const int *p']) gen.add_cast(std_vector_int, int_ptr, lambda in_var, out_var: '%s = ((std::vector<int> *)%s)->data();\n' % (out_var, in_var)) std_vector_int_ptr = gen.begin_class('std::vector<int*>', features={'sequence': lib.std.VectorSequenceFeature(int_ptr)}) if gen.get_language() == 'CPython': gen.bind_constructor(std_vector_int_ptr, ['?PySequenceOfInt_ptr sequence']) elif gen.get_language() == 'Lua': gen.bind_constructor(std_vector_int_ptr, ['?LuaTableOfInt_ptr sequence']) gen.bind_method(std_vector_int_ptr, 'size', 'int', []) gen.bind_method(std_vector_int_ptr, 'push_back', 'void', ['int* v']) gen.bind_method(std_vector_int_ptr, 'at', 'int*&', ['int pos']) gen.bind_method(std_vector_int_ptr, 'data', 'int**', []) gen.end_class(std_vector_int_ptr) gen.finalize() return gen.get_output()
def bind_test(gen): gen.start('my_test') lib.bind_defaults(gen) # inject test code in the wrapper gen.insert_code( '''\ struct simple_struct { simple_struct() : a(1) {} simple_struct(int v) : a(v) {} int set_a(int v) { return a = v; } bool set_a(int v0, int v1) { a = v0 + v1; return true; } int get_a() { return a; } static int get_static_int() { return 4; } int a; }; void get_modify_arg_out(simple_struct &v, simple_struct k=simple_struct()) { v.a = 3 * k.a + v.a; } struct simple_struct2 { simple_struct2() : a(1) {} simple_struct2(int v) : a(v) {} simple_struct2(simple_struct v) : a(v.a) {} int a; }; void get_modify_arg_out2(simple_struct2 &v, simple_struct k=simple_struct()) { v.a = 3 * k.a + v.a; } ''', True, False) simple_struct = gen.begin_class('simple_struct') gen.bind_constructor_overloads(simple_struct, [([], { "bound_name": "SimplestConstructor" }), (['int v'], [])]) gen.bind_method_overloads(simple_struct, 'set_a', [('int', ['int v'], []), ('bool', ['int v0', 'int v1'], [])]) gen.bind_method(simple_struct, 'get_a', 'int', []) gen.bind_static_method(simple_struct, 'get_static_int', 'int', []) gen.end_class(simple_struct) gen.bind_function('get_modify_arg_out', 'void', ['simple_struct &v', '?simple_struct k'], {'arg_out': ['v']}) simple_struct2 = gen.begin_class('simple_struct2') gen.bind_constructor_overloads(simple_struct2, [([], []), (['int v'], []), (['simple_struct v'], { "bound_name": "WithOtherStruct" })]) gen.bind_members(simple_struct2, ['int a']) gen.end_class(simple_struct2) gen.bind_function('get_modify_arg_out2', 'void', ['simple_struct2 &v', '?simple_struct k'], {'arg_out': ['v']}) gen.finalize() return gen.get_output()