cpp_glue.rs.in

use std::{
    cell::{Ref, RefCell, RefMut},
    f32, f64,
    path::Path,
    rc::Rc,
};

#[derive(Clone)]
pub struct Foo {
    data: i32,
    name: String,
}

impl Foo {
    fn new(data: i32, name: &str) -> Foo {
        //println!("Foo::new name '{}'", name);
        Foo {
            data,
            name: name.to_string(),
        }
    }
    fn f(&self, a: i32, b: i32) -> i32 {
        //println!("Foo::f {} {} {}", self.data, a, b);
        self.data + a + b
    }
    fn name(&self) -> &str {
        &self.name
    }
    fn set_field(&mut self, v: i32) {
        self.data = v;
    }
    fn call_me(cb: Box<dyn SomeObserver>) {
        //println!("call_me begin");
        cb.on_state_changed(2, false);
        cb.on_state_changed_without_args();
        assert!(cb.is_odd(1));
        assert!(!cb.is_odd(2));
    }
    fn one_and_half(&self) -> f64 {
        f64::from(self.data) * 1.5
    }

    fn f_double(&self, a: f64, b: f64) -> f64 {
        a.hypot(b) + f64::from(self.data)
    }

    fn ret_string(&self) -> String {
        self.name.clone()
    }
}

fn f_hypot(a: f64, b: f64) -> f64 {
    a.hypot(b)
}

trait SomeObserver {
    fn on_state_changed(&self, _: i32, _: bool);
    fn on_state_changed_without_args(&self);
    fn is_odd(&self, x: i32) -> bool;
}

foreign_callback!(callback SomeObserver {
    self_type SomeObserver;
    onStateChanged = SomeObserver::on_state_changed(&self, _: i32, _: bool);
    onStateChangedWithoutArgs = SomeObserver::on_state_changed_without_args(&self);
    isOdd = SomeObserver::is_odd(&self, x: i32) -> bool;
});

foreign_class!(class Foo {
    self_type Foo;
    constructor Foo::new(_: i32, _: &str) -> Foo;
    fn Foo::f(&self, a: i32, b: i32) -> i32;
    fn Foo::f_double(&self, _: f64, _: f64) -> f64;
    fn Foo::name(&self) -> &str; alias getName;
    fn Foo::set_field(&mut self, v: i32);
    fn Foo::one_and_half(&self) -> f64;
    fn Foo::call_me(_: Box<dyn SomeObserver>);
    fn f_hypot(_: f64, _: f64) -> f64; alias fHypot;
    fn Foo::ret_string(&self) -> String;
    foreigner_code r#"
public:
    size_t cpp_func(const std::string &s) const { return s.size(); }
    FooWrapper() noexcept: FooWrapper(nullptr) {}
"#;
});

pub struct CheckPrimitiveTypesClass {
    a: i32,
}

impl CheckPrimitiveTypesClass {
    fn new() -> CheckPrimitiveTypesClass {
        CheckPrimitiveTypesClass { a: 17 }
    }
    fn test(&self, a: bool) -> f32 {
        if a {
            f32::consts::E
        } else {
            f32::consts::PI
        }
    }
    fn set_a(&mut self, val: i32) {
        self.a = val;
    }
    fn get_a(&self) -> i32 {
        self.a
    }
}

fn create_boo() -> Rc<RefCell<CheckPrimitiveTypesClass>> {
    Rc::new(RefCell::new(CheckPrimitiveTypesClass::new()))
}

fn test_u8(v: u8) -> u8 {
    v + 1
}

fn test_i8(v: i8) -> i8 {
    v + 1
}

fn test_u16(v: u16) -> u16 {
    v + 1
}

fn test_i16(v: i16) -> i16 {
    v + 1
}

fn test_i32(v: i32) -> i32 {
    v + 1
}

fn test_u32(v: u32) -> u32 {
    v + 1
}

fn test_u64(v: u64) -> u64 {
    v + 1
}

fn test_i64(v: i64) -> i64 {
    v + 1
}

fn test_f32(v: f32) -> f32 {
    v + 1.
}
fn test_f64(v: f64) -> f64 {
    v + 1.
}

fn invert(v: bool) -> bool {
    !v
}

fn xor(x: bool, y: bool) -> bool {
    x ^ y
}

foreign_class!(class CheckPrimitiveTypesClass {
    self_type CheckPrimitiveTypesClass;
    constructor create_boo() -> Rc<RefCell<CheckPrimitiveTypesClass>>;
    fn CheckPrimitiveTypesClass::test(&self, _: bool) -> f32;
    fn CheckPrimitiveTypesClass::set_a(&mut self, _: i32); alias setA;
    fn CheckPrimitiveTypesClass::get_a(&self) -> i32; alias getA;
    fn test_u8(v: u8) -> u8;
    fn test_i8(v: i8) -> i8;
    fn test_u16(v: u16) -> u16;
    fn test_i16(v: i16) -> i16;
    fn test_i32(v: i32) -> i32;
    fn test_u32(v: u32) -> u32;
    fn test_u64(v: u64) -> u64;
    fn test_i64(v: i64) -> i64;
    fn test_f32(v: f32) -> f32;
    fn test_f64(v: f64) -> f64;
    fn invert(_: bool) -> bool;
    fn xor(_: bool, _: bool) -> bool; alias Xor;
});

pub struct ClassCooperationTest {
    data: Vec<Foo>,
}

impl ClassCooperationTest {
    fn new() -> ClassCooperationTest {
        ClassCooperationTest {
            data: vec![Foo::new(5, "5"), Foo::new(6, "7")],
        }
    }
    fn get(&self, idx: u32) -> Foo {
        self.data[idx as usize].clone()
    }
    fn set(&mut self, idx: u32, foo: Foo) {
        self.data[idx as usize] = foo;
    }
}

foreign_class!(class ClassCooperationTest {
    self_type ClassCooperationTest;
    constructor ClassCooperationTest::new() -> ClassCooperationTest;
    fn ClassCooperationTest::get(&self, _: u32) -> Foo;
    fn ClassCooperationTest::set(&mut self, _: u32, _: Foo);
});

trait DummySetterGetter {
    fn get(&self) -> i32;
    fn set(&mut self, _: i32);
}

pub struct TestObjectLifetime<'a> {
    data: Box<dyn DummySetterGetter + 'a>,
}

impl DummySetterGetter for i32 {
    fn get(&self) -> i32 {
        *self
    }
    fn set(&mut self, x: i32) {
        *self = x;
    }
}
impl<'a> TestObjectLifetime<'a> {
    fn set_data(&mut self, v1: i8, v2: i16, v3: i32, v4: f64, v5: f32) {
        self.data
            .set(i32::from(v1) + i32::from(v2) + v3 + v4 as i32 + v5 as i32);
    }

    fn get_data(&self) -> i32 {
        self.data.get()
    }
}

fn create_test_obj_with_lifetime<'a>() -> TestObjectLifetime<'a> {
    TestObjectLifetime { data: Box::new(5) }
}

foreign_class!(class TestObjectLifetime {
    self_type TestObjectLifetime<'a>;
    constructor create_test_obj_with_lifetime() -> TestObjectLifetime<'a>;
    fn TestObjectLifetime::set_data(&mut self, v1: i8, v2: i16, v3: i32, v4: f64, v5: f32);
    fn TestObjectLifetime::get_data(&self) -> i32;
});

pub struct TestWorkWithVec {
    data_tag: String,
    vec_u32: Vec<u32>,
    vec_foo: Vec<Foo>,
    vec_usize: Vec<usize>,
}

impl TestWorkWithVec {
    fn new(tag: &str) -> TestWorkWithVec {
        //println!("tag: {}", tag);
        let n = tag.len();
        let mut vec_u32 = Vec::<u32>::with_capacity(n);
        for i in 0..n {
            vec_u32.push(i as u32);
        }
        vec_u32.push(1_u32 << 30);

        let mut vec_foo = Vec::<Foo>::with_capacity(n);
        for i in 0..n {
            vec_foo.push(Foo::new(i as i32, tag));
        }

        TestWorkWithVec {
            data_tag: tag.to_string(),
            vec_u32,
            vec_foo,
            vec_usize: vec![17, 18],
        }
    }
    fn get_bytes(&self, n: u32) -> Vec<u8> {
        //println!("get_bytes n {}", n);
        let mut res = String::new();
        for _ in 0..n {
            res.push_str(&self.data_tag);
        }
        res.into_bytes()
    }

    fn get_vec_u32(&self) -> Vec<u32> {
        self.vec_u32.clone()
    }

    fn get_u32_slice(&self) -> &[u32] {
        &self.vec_u32
    }

    fn get_vec_f32(&self) -> Vec<f32> {
        vec![f32::consts::E, f32::consts::PI]
    }

    fn get_vec_f64(&self) -> Vec<f64> {
        vec![f64::consts::E, f64::consts::PI]
    }

    fn get_vec_foo(&self) -> Vec<Foo> {
        self.vec_foo.clone()
    }

    fn get_slice_foo(&self) -> &[Foo] {
        &self.vec_foo
    }
    fn set_vec_foo(&mut self, v: Vec<Foo>) {
        self.vec_foo = v;
    }
    fn create_foo_vec(n: usize) -> Vec<Foo> {
        let mut v = Vec::with_capacity(n);
        for i in 0..n {
            v.push(Foo::new(i as i32, &format!("{}", i)));
        }
        v
    }
    fn sort_foo_slice(v: &mut [Foo]) {
        v.sort_by(|ref x, ref y| x.data.cmp(&y.data))
    }
    fn clone_foo_slice(v: &[Foo]) -> Vec<Foo> {
        v.to_vec()
    }
    fn return_usize_slice(&self) -> &[usize] {
        &self.vec_usize
    }
    fn return_usize_vec(&self) -> Vec<usize> {
        self.vec_usize.clone()
    }
    fn test_i32_slice(a: &[i32]) -> Vec<i32> {
        let mut v = Vec::with_capacity(a.len());
        for x in a {
            v.push(*x + 1);
        }
        v
    }
    fn test_lifetime_objs<'a>(n: usize) -> Vec<TestObjectLifetime<'a>> {
        let mut ret = Vec::with_capacity(n);
        for i in 0..n {
            let mut obj = create_test_obj_with_lifetime();
            obj.data.set(i as i32);
            ret.push(obj);
        }
        ret
    }
}

foreign_class!(class TestWorkWithVec {
    self_type TestWorkWithVec;
    constructor TestWorkWithVec::new(_: &str) -> TestWorkWithVec;
    fn TestWorkWithVec::get_bytes(&self, n: u32) -> Vec<u8>;
    fn TestWorkWithVec::get_u32_slice(&self) -> &[u32];
    fn TestWorkWithVec::get_vec_u32(&self) -> Vec<u32>;
    fn TestWorkWithVec::get_vec_f32(&self) -> Vec<f32>;
    fn TestWorkWithVec::get_vec_f64(&self) -> Vec<f64>;
    fn TestWorkWithVec::get_vec_foo(&self) -> Vec<Foo>;
    fn TestWorkWithVec::get_slice_foo(&self) -> &[Foo];
    fn TestWorkWithVec::create_foo_vec(n: usize) -> Vec<Foo>;
    fn TestWorkWithVec::sort_foo_slice(v: &mut [Foo]);
    fn TestWorkWithVec::return_usize_slice(&self) -> &[usize];
    fn TestWorkWithVec::return_usize_vec(&self) -> Vec<usize>;
    fn TestWorkWithVec::clone_foo_slice(v: &[Foo]) -> Vec<Foo>;
    fn TestWorkWithVec::test_i32_slice(a: &[i32]) -> Vec<i32>;
    fn TestWorkWithVec::set_vec_foo(&mut self, v: Vec<Foo>);
    fn TestWorkWithVec::test_lifetime_objs<'a>(n: usize) -> Vec<TestObjectLifetime<'a>>;
    fn sort_i32_slice(arr: &mut [i32]) {
        arr.sort();
    }
});

enum MyEnum {
    Item1,
    Item2,
    Item3,
}

foreign_enum!(
    enum MyEnum {
        ITEM1 = MyEnum::Item1,
        ITEM2 = MyEnum::Item2,
        ITEM3 = MyEnum::Item3,
    }
);

#[derive(Default)]
pub struct TestEnumClass;

impl TestEnumClass {
    fn f1(&mut self, v: MyEnum) -> i32 {
        if let MyEnum::Item2 = v {
            17
        } else {
            -5
        }
    }

    fn next_enum(v: MyEnum) -> MyEnum {
        use self::MyEnum::*;
        match v {
            Item1 => Item2,
            Item2 => Item3,
            Item3 => Item1,
        }
    }
}

foreign_class!(class TestEnumClass {
    self_type TestEnumClass;
    constructor TestEnumClass::default() -> TestEnumClass;
    fn TestEnumClass::f1(&mut self, v: MyEnum) -> i32;
    fn TestEnumClass::next_enum(v: MyEnum) -> MyEnum;
});

#[derive(Default)]
pub struct TestPassPathAsParam {
    a: String,
}

impl TestPassPathAsParam {
    fn set_path(&mut self, p: &Path) {
        self.a = format!("{:?}", p);
    }
    fn path(&self) -> &str {
        &self.a
    }
}

foreign_class!(class TestPassPathAsParam {
    self_type TestPassPathAsParam;
    constructor TestPassPathAsParam::default() -> TestPassPathAsParam;
    fn TestPassPathAsParam::set_path(&mut self, p: &Path);
    fn TestPassPathAsParam::path(&self) -> &str;
});

pub struct TestOptional {
    foo: Foo,
}

impl Default for TestOptional {
    fn default() -> TestOptional {
        TestOptional {
            foo: Foo::new(5, "aaa"),
        }
    }
}
impl TestOptional {
    fn f1(&self, ret_notnull: bool) -> Option<Foo> {
        if ret_notnull {
            Some(Foo::new(17, "17"))
        } else {
            None
        }
    }

    fn f2(&self, ret_notnull: bool) -> Option<f64> {
        if ret_notnull {
            Some(f64::consts::E)
        } else {
            None
        }
    }

    fn f3(&self, ret_notnull: bool) -> Option<u32> {
        if ret_notnull {
            Some(17)
        } else {
            None
        }
    }
    fn f4(&self, a: Option<f64>) -> f64 {
        a.map(|v| v * 2.).unwrap_or(-1.)
    }
    fn f5(&self, x: bool) -> Option<&Foo> {
        if x {
            Some(&self.foo)
        } else {
            None
        }
    }
    fn f6(&mut self, a: Option<Foo>) {
        if let Some(x) = a {
            self.foo = x;
        }
    }
    fn f7(&self) -> Option<MyEnum> {
        Some(MyEnum::Item1)
    }
    fn f8(&self, x: Option<MyEnum>) -> Option<MyEnum> {
        x.map(TestEnumClass::next_enum)
    }
    fn f9(&self, x: Option<&str>) -> String {
        x.map(|x| format!("your name is {}", x))
            .unwrap_or_else(|| "None".to_string())
    }
    fn f10(&self, is_some: bool) -> Option<&str> {
        if is_some {
            Some(self.foo.name())
        } else {
            None
        }
    }
    fn f11(&self, val: i32, is_some: bool) -> Option<i32> {
        if is_some {
            Some(val)
        } else {
            None
        }
    }
    fn f12(&self, val: f32, is_some: bool) -> Option<f32> {
        if is_some {
            Some(val)
        } else {
            None
        }
    }
    fn f13(&self, is_some: bool) -> Option<String> {
        if is_some {
            Some(
                r#"There was a Young Lady whose nose,
Was so long that it reached to her toes;
So she hired an Old Lady,
Whose conduct was steady,
To carry that wonderful nose."#
                    .into(),
            )
        } else {
            None
        }
    }
    fn f14(&self, is_some: bool) -> Option<bool> {
        if is_some {
            Some(true)
        } else {
            None
        }
    }
}

foreign_class!(class TestOptional {
    self_type TestOptional;
    constructor TestOptional::default() -> TestOptional;
    fn TestOptional::f1(&self, _: bool) -> Option<Foo>;
    fn TestOptional::f2(&self, ret_notnull: bool) -> Option<f64>;
    fn TestOptional::f3(&self, ret_notnull: bool) -> Option<u32>;
    fn TestOptional::f4(&self, _: Option<f64>) -> f64;
    fn TestOptional::f5(&self, x: bool) -> Option<&Foo>;
    fn TestOptional::f6(&mut self, a: Option<Foo>);
    fn TestOptional::f7(&self) -> Option<MyEnum>;
    fn TestOptional::f8(&self, x: Option<MyEnum>) -> Option<MyEnum>;
    fn TestOptional::f9(&self, x: Option<&str>) -> String;
    fn TestOptional::f10(&self, is_some: bool) -> Option<&str>;
    fn TestOptional::f11(&self, val: i32, is_some: bool) -> Option<i32>;
    fn TestOptional::f12(&self, val: f32, is_some: bool) -> Option<f32>;
    fn TestOptional::f13(&self, is_some: bool) -> Option<String>;
    fn TestOptional::f14(&self, is_some: bool) -> Option<bool>;
    fn f15(foo: Option<&Foo>) -> Option<String> {
        foo.map(|x| x.name.clone())
    }
    fn f16(mut foo: Option<&mut Foo>, v: i32) {
        foo.as_mut().map(|x| x.set_field(v));
    }
});

#[derive(Default)]
pub struct TestResult {}

impl TestResult {
    fn new_with_err() -> Result<TestResult, String> {
        Err("this is error".to_string())
    }
    fn f(is_ok: bool) -> Result<(), String> {
        if is_ok {
            Ok(())
        } else {
            Err("Not ok".to_string())
        }
    }

    fn f_vec(is_ok: bool) -> Result<Vec<Foo>, String> {
        if is_ok {
            Ok(vec![Foo::new(15, "15"), Foo::new(13, "13")])
        } else {
            Err("Not ok".to_string())
        }
    }
    fn f2(is_ok: bool) -> Result<Foo, TestError> {
        if is_ok {
            Ok(Foo::new(17, "ok"))
        } else {
            Err(TestError {
                msg: "Not ok".to_string(),
            })
        }
    }

    fn f3(is_ok: bool) -> Result<Vec<Foo>, TestError> {
        if is_ok {
            Ok(vec![Foo::new(40, "40"), Foo::new(60, "")])
        } else {
            Err(TestError {
                msg: "Not ok".to_string(),
            })
        }
    }

    fn f4(is_ok: bool) -> Result<Vec<u8>, TestError> {
        if is_ok {
            Ok(vec![17, 18])
        } else {
            Err(TestError {
                msg: "Not ok".to_string(),
            })
        }
    }
    fn f5(is_ok: bool) -> Result<Foo, ErrorEnum> {
        if is_ok {
            Ok(Foo::new(17, "ok"))
        } else {
            Err(ErrorEnum::B)
        }
    }
    fn f6(is_ok: bool, val: i64) -> Result<i64, TestError> {
        if is_ok {
            Ok(val + 1)
        } else {
            Err(TestError {
                msg: "Not ok".into(),
            })
        }
    }

    fn f_res_opt(var: u32) -> Result<Option<Foo>, String> {
        match var {
            0 => Ok(Some(Foo::new(17, "17"))),
            1 => Ok(None),
            2 => Err("this is bad".into()),
            _ => panic!("unknown var {}", var),
        }
    }
}

#[derive(Default)]
pub struct TestError {
    msg: String,
}
impl TestError {
    fn to_string(&self) -> String {
        self.msg.clone()
    }
}

foreign_class!(class TestError {
    self_type TestError;
    constructor TestError::default() -> TestError;
    fn TestError::to_string(&self) -> String;
});

pub enum ErrorEnum {
    A,
    B,
}

foreign_enum!(
    enum ErrorEnum {
        eeA = ErrorEnum::A,
        eeB = ErrorEnum::B,
    }
);

foreign_class!(class TestResult {
    self_type TestResult;
    private constructor TestResult::default() -> TestResult;
    fn TestResult::new_with_err() -> Result<TestResult, String>;
    fn TestResult::f(_: bool) -> Result<(), String>;
    fn TestResult::f_vec(_: bool) -> Result<Vec<Foo>, String>;
    fn TestResult::f2(_: bool) -> Result<Foo, TestError>;
    fn TestResult::f3(_: bool) -> Result<Vec<Foo>, TestError>;
    fn TestResult::f4(is_ok: bool) -> Result<Vec<u8>, TestError>;
    fn TestResult::f5(is_ok: bool) -> Result<Foo, ErrorEnum>;
    fn TestResult::f6(is_ok: bool, val: i64) -> Result<i64, TestError>;
    fn TestResult::f_res_opt(var: u32) -> Result<Option<Foo>, String>;
});

pub struct TestReferences {
    foo: Foo,
}

impl TestReferences {
    fn new(foo_data: i32, foo_name: &str) -> TestReferences {
        TestReferences {
            foo: Foo::new(foo_data, foo_name),
        }
    }

    fn get_foo_ref(&self) -> &Foo {
        &self.foo
    }

    fn update_foo(&mut self, foo: &Foo) {
        self.foo = foo.clone();
    }

    fn update_mut_foo(&mut self, foo: &mut Foo) {
        self.foo = foo.clone();
        foo.name.push('A');
    }
    fn check_rc_pass1(x: &CheckPrimitiveTypesClass) -> i32 {
        x.a
    }
    fn check_rc_pass2(x: &mut CheckPrimitiveTypesClass) -> i32 {
        x.a += 42;
        x.a
    }
}

foreign_class!(class TestReferences {
    self_type TestReferences;
    constructor TestReferences::new(foo_data: i32, foo_name: &str) -> TestReferences;
    fn TestReferences::get_foo_ref(&self) -> &Foo;
    fn TestReferences::update_foo(&mut self, foo: &Foo);
    fn TestReferences::update_mut_foo(&mut self, foo: &mut Foo);
    fn TestReferences::check_rc_pass1(x: &CheckPrimitiveTypesClass) -> i32;
    fn TestReferences::check_rc_pass2(x: &mut CheckPrimitiveTypesClass) -> i32;
});

fn add_func(a: i32, b: i32) -> i32 {
    a + b
}

foreign_class!(class TestOnlyStaticMethods {
    fn add_func(_: i32, _: i32) -> i32;
});

pub struct GnssInfo {
    lat: f64,
}

impl GnssInfo {
    fn latitude(&self) -> f64 {
        self.lat
    }
}

foreign_class!(class Position {
    self_type GnssInfo;
    private constructor = empty;
    fn GnssInfo::latitude(&self) -> f64;
});

struct LocationService;

impl LocationService {
    fn position() -> Result<GnssInfo, String> {
        Ok(GnssInfo { lat: 0.1 })
    }
}

foreign_class!(class LocationService {
    fn LocationService::position() -> Result<GnssInfo, String>;
});

//ANCHOR: boxed_trait
pub trait Interface {
    fn f(&self, _: i32) -> i32;
    fn set(&mut self, _: i32);
}
struct InterfaceImpl {
    base: i32,
}

impl Interface for InterfaceImpl {
    fn f(&self, x: i32) -> i32 {
        self.base + x
    }
    fn set(&mut self, x: i32) {
        self.base = x;
    }
}

fn create_interface() -> Box<Box<dyn Interface>> {
    Box::new(Box::new(InterfaceImpl { base: 17 }))
}

foreign_class!(class Interface {
    self_type dyn Interface;
    constructor create_interface() -> Box<Box<dyn Interface>>;
    fn Interface::f(&self, _: i32) -> i32;
    fn Interface::set(&mut self, x: i32);
});
//ANCHOR_END: boxed_trait

#[derive(Default)]
pub struct TestPassInterface;

foreign_class!(class TestPassInterface {
    self_type TestPassInterface;
    constructor TestPassInterface::default() -> TestPassInterface;
    fn use_interface(a: Box<Box<dyn Interface>>, b: i32) -> i32 {
        (**a).f(b)
    }
});

foreign_callback!(callback ToString {
    self_type ::std::string::ToString;
    toString = ::std::string::ToString::to_string(&self) -> String;
});

pub struct RecursiveStruct {
    tag: String,
    childs: Vec<RecursiveStruct>,
}

impl RecursiveStruct {
    pub fn tag(&self) -> &str {
        &self.tag
    }
    pub fn childs(&self) -> &[RecursiveStruct] {
        &self.childs
    }
    pub fn create_with_two_childs(
        name: String,
        child1_name: String,
        child2_name: String,
    ) -> RecursiveStruct {
        RecursiveStruct {
            tag: name,
            childs: vec![
                RecursiveStruct {
                    tag: child1_name,
                    childs: vec![],
                },
                RecursiveStruct {
                    tag: child2_name,
                    childs: vec![],
                },
            ],
        }
    }
}

foreign_class!(class RecursiveStruct {
    self_type RecursiveStruct;
    constructor RecursiveStruct::create_with_two_childs(
        name: String,
        child1_name: String,
        child2_name: String,
    ) -> RecursiveStruct;
    fn RecursiveStruct::tag(&self) -> &str;
    fn RecursiveStruct::childs(&self) -> &[RecursiveStruct];
});

pub struct Boo {
    f1: i32,
}

impl Boo {
    pub fn f(&self) -> i32 {
        self.f1
    }
    pub fn return_pair_obj1() -> (Foo, Boo) {
        (
            Foo {
                data: 5,
                name: "FooName".into(),
            },
            Boo { f1: 17 },
        )
    }
    pub fn return_pair_obj2() -> (Boo, Foo) {
        (
            Boo { f1: 17 },
            Foo {
                data: 5,
                name: "FooName".into(),
            },
        )
    }
    pub fn return_pair_f32_i32() -> (f32, i32) {
        (42.42, 17)
    }
    pub fn swap_foo_boo((foo, boo): (Foo, Boo)) -> (Boo, Foo) {
        (boo, foo)
    }
}

foreign_class!(class Boo {
    self_type Boo;
    private constructor = empty;
    fn Boo::f(&self) -> i32;
});

foreign_class!(class TestPair {
    fn Boo::return_pair_obj1() -> (Foo, Boo);
    fn Boo::return_pair_obj2() -> (Boo, Foo);
    fn Boo::return_pair_f32_i32() -> (f32, i32);
    fn Boo::swap_foo_boo(foo_boo: (Foo, Boo)) -> (Boo, Foo);
    fn return_tuple3() -> (bool, i32, String) {
        (true, 17, "tuple3".to_string())
    }
});

#[derive(Clone)]
pub struct TestCopy {
    s: String,
}

impl TestCopy {
    pub fn new(s: &str) -> Self {
        TestCopy { s: s.into() }
    }
    pub fn get(&self) -> &str {
        &self.s
    }
}

foreign_class!(
    #[derive(Copy)]
    class TestCopy {
        self_type TestCopy;
        constructor TestCopy::new(s: &str) -> TestCopy;
        fn TestCopy::get(&self) -> &str;
        fn TestCopy::clone(&self) -> TestCopy;
    });

#[derive(Default)]
pub struct GetSetStrTest {
    s: String,
}

impl GetSetStrTest {
    fn get_str(&self) -> &str {
        &self.s
    }
    fn set_str(&mut self, x: &str) {
        self.s = x.into();
    }
}

foreign_class!(class GetSetStrTest {
    self_type GetSetStrTest;
    constructor GetSetStrTest::default() -> GetSetStrTest;
    fn GetSetStrTest::get_str(&self) -> &str;
    fn GetSetStrTest::set_str(&mut self, _: &str);
});

#[repr(C)]
#[derive(Clone, Copy, Default, Debug, PartialEq)]
pub struct Vec2 {
    x: f32,
    y: f32,
}

foreign_typemap!(
    define_c_type!(
        module = "vec2.h";
        #[repr(C)]
        struct Vec2 {
            x: f32,
            y: f32,
        }
    );
    (r_type) Vec2;
    (f_type) "Vec2";
);

fn inc_vec2(v: Vec2) -> Vec2 {
    Vec2 {
        x: v.x + 1.1,
        y: v.y + 1.,
    }
}

foreign_class!(class TestWorkWithReprC {
    fn inc_vec2(v: Vec2) -> Vec2;
});

// ANCHOR: inline_method
foreign_class!(class TestFnInline {
    fn int_to_str(a: i32) -> String {
        format!("{}", a)
    }
});
// ANCHOR_END: inline_method

foreign_typemap!(
    generic_alias!(CFnOnce = swig_concat_idents!(CFnOnce, swig_i_type!(T, output)));
    define_c_type!(
        module = "CFnOnce!().h";
        #[repr(C)]
        pub struct CFnOnce!() {
            cb: extern "C" fn(swig_i_type!(T, output), *mut ::std::os::raw::c_void),
            ctx: *mut ::std::os::raw::c_void,
        });

    ($p:r_type) <T> impl FnOnce(T) <= CFnOnce!()
    {
        $out_no_type = move |x| {
            swig_from_rust_to_i_type!(T, x, x)
            ($p.cb)(x, $p.ctx);
        };
    };

    ($p:f_type, $tmp:temporary, input_to_output, req_modules = ["\"CFnOnce!().h\"", "<future>"]) <= "std::future<swig_f_type!(T, output)>"
        r#"
        auto $tmp = new std::promise<swig_f_type!(T, output)>;
        auto $p = $tmp->get_future();
        $out;
        $out.ctx = $tmp;
        $out.cb = [](swig_i_type!(T, output) arg, void *opaque) {
            auto arg_cpp = swig_foreign_from_i_type!(T, arg);
            auto promise = static_cast<std::promise<swig_f_type!(T, output)> *>(opaque);
            promise->set_value(std::move(arg_cpp));
            delete promise;
        };
"#;
);

unsafe impl Send for CFnOnceCRustResultCRustForeignVecCRustString {}

foreign_class!(class TestFuture {
    fn call_fn(f: impl FnOnce(Foo)) {
        f(Foo::new(-1, "from callback"));
    }

    fn call_fn2(is_ok: bool, f: impl FnOnce(Result<Vec<Foo>, String>)) {
        std::thread::spawn(move || {
        if is_ok {
            f(Ok(vec![Foo::new(-1, "from callback")]));
        } else {
            f(Err("Err".to_string()));
        }
        });
    }
});

//ANCHOR: method_not_method
pub struct TestMethodNotMethod;

impl TestMethodNotMethod {
    fn new() -> Self {
        TestMethodNotMethod
    }
}

fn method_not_method(_this: &TestMethodNotMethod) {}

foreign_class!(class TestMethodNotMethod {
    self_type TestMethodNotMethod;
    constructor TestMethodNotMethod::new() -> TestMethodNotMethod;
    fn method_not_method(&self);
});
//ANCHOR_END: method_not_method

trait OnThreadEvent {
    fn something_change_in_other_thread(&self, x: i32, s: String);
}

foreign_interface!(interface ThreadSafeObserver {
    self_type OnThreadEvent + Send;
    onStateChanged = OnThreadEvent::something_change_in_other_thread(&self, x: i32, s: String);
});

foreign_class!(class TestMultiThreadCallback {
    fn f(cb: Box<dyn OnThreadEvent + Send>) {
        std::thread::spawn(move || {
            cb.something_change_in_other_thread(42, "15".into());
        });
    }
});

pub struct Session {
    name: String,
}

foreign_class!(
    #[derive(SmartPtrCopy)]
    class Session {
        self_type Session;
        constructor session_init(name: &str) -> Rc<RefCell<Session>> {
            Rc::new(RefCell::new(Session {
                name: name.into(),
            }))
        }
        fn name(&self) -> &str {
            &this.name
        }
    }
);