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()
