rsbind 0.6.0

Provide tools to bind rust trait with other language and export library artifact directly. Invoke rust functions just like you write it in native language.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79

use rstgen::swift::{local, Argument, Constructor, Field, Method, Modifier, Swift};
use rstgen::{swift, IntoTokens};

use crate::ast::contract::desc::StructDesc;
use crate::base::lang::{Convertible, Direction};
use crate::errors::*;
use crate::swift::converter::SwiftConvert;
use crate::swift::types::{to_swift_file, SwiftType};

pub(crate) struct StructGen<'a> {
    pub desc: &'a StructDesc,
}

impl<'a> StructGen<'a> {
    pub fn gen(&self) -> Result<String> {
        let mut struct_ = swift::Struct::new(self.desc.name.clone());
        struct_.modifiers.push(Modifier::Public);
        struct_.implements.push(local("Codable"));

        let mut constructor1 = Constructor::new();
        constructor1.modifiers = vec![Modifier::Public];
        for arg in self.desc.fields.iter() {
            let field_ty = SwiftType::new(arg.ty.clone());
            let swift_ty = Swift::from(field_ty);
            let mut swift_field = Field::new(swift_ty.clone(), arg.name.clone());
            swift_field.modifiers = vec![Modifier::Public];
            struct_.fields.push(swift_field);

            constructor1
                .arguments
                .push(Argument::new(swift_ty.clone(), arg.name.clone()));
            push_f!(constructor1.body, "self.{} = {}", arg.name, arg.name);
        }
        struct_.constructors.push(constructor1);
        struct_.constructors.push(self.create_proxy_constructor());
        struct_.methods.push(self.create_into_proxy_fn());

        to_swift_file(struct_.into_tokens())
    }

    fn create_into_proxy_fn(&self) -> Method {
        let mut method = swift::Method::new("intoProxy");
        method.modifiers = vec![Modifier::Internal];
        method.returns(swift::local(format!("Proxy{}", &self.desc.name)));
        push_f!(method.body, "return Proxy{} (", self.desc.name);
        for (index, field) in self.desc.fields.iter().enumerate() {
            let convert = SwiftConvert {
                ty: field.ty.clone(),
            }
            .native_to_transferable(format!("self.{}", &field.name), Direction::Down);
            nested_f!(method.body, "{} : {}", field.name, convert);
            if index != self.desc.fields.len() - 1 {
                method.body.append(",")
            }
        }
        push!(method.body, ")");

        method
    }

    fn create_proxy_constructor(&self) -> Constructor {
        let mut constructor2 = Constructor::new();
        constructor2.modifiers = vec![Modifier::Internal];
        constructor2.arguments.push(Argument::new(
            swift::local(format!("Proxy{}", &self.desc.name)),
            "proxy",
        ));

        for field in self.desc.fields.iter() {
            let convert = SwiftConvert {
                ty: field.ty.clone(),
            }
            .transferable_to_native(format!("proxy.{}", &field.name), Direction::Down);
            push_f!(constructor2.body, "self.{} = {}", field.name, convert);
        }

        constructor2
    }
}