rs4j 0.10.2

A small, automatic, efficient, and easy-to-use Rust to Java bridge.
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
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118

//! Class codegen context

use crate::if_else;

use super::{generic::TypeGeneric, Class};

/// A codegen context for classes
#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub struct ClassCtx {
    /// The class name
    pub name: String,

    /// The package name
    pub package: String,

    /// Generics
    pub generics: Vec<TypeGeneric>,

    /// Is the class a wrapper?
    pub wrapped: bool,
}

impl ClassCtx {
    /// Create a new [`ClassCtx`].
    pub fn new(class: &Class) -> Self {
        Self {
            name: class.name.clone(),
            package: class.package.clone(),
            generics: class.generics.clone(),
            wrapped: class.wrapped,
        }
    }

    /// The base name for Rust methods
    pub fn base_name(&self) -> String {
        format!("{}_{}", self.package.replace(".", "_"), &self.name)
    }

    /// Make a method name
    pub fn method_name(&self, method: impl AsRef<str>) -> String {
        format!(
            "{}_{}",
            self.base_name(),
            method.as_ref().replace("_", "_1")
        )
    }

    /// Get the name of the wrapper struct
    pub fn name(&self) -> String {
        format!("__JNI_{}", &self.name)
    }

    /// Get the name of the wrapper struct with generics
    pub fn name_generics(&self) -> String {
        let generics = self
            .generics
            .iter()
            .map(|v| v.name.to_owned())
            .collect::<Vec<_>>()
            .join(", ");

        let generics = if_else!(generics != "", format!("<{}>", generics), "".into());

        format!("__JNI_{}{}", &self.name, generics)
    }

    /// Get the name of the struct with generics
    pub fn raw_name_generics(&self) -> String {
        let generics = self
            .generics
            .iter()
            .map(|v| v.name.to_owned())
            .collect::<Vec<_>>()
            .join(", ");

        let generics = if_else!(generics != "", format!("<{}>", generics), "".into());

        format!("{}{}", &self.name, generics)
    }

    /// Get the name of the class with generics for Java
    pub fn raw_name_generics_java(&self) -> String {
        let generics = self
            .generics
            .iter()
            .map(|v| format!("{} extends ParentClass & NativeClass", v.name))
            .collect::<Vec<_>>()
            .join(", ");

        let generics = if_else!(generics != "", format!("<{}>", generics), "".into());

        format!("{}{}", &self.name, generics)
    }

    /// Get generics for Java
    pub fn generics_java(&self) -> String {
        let generics = self
            .generics
            .iter()
            .map(|v| format!("{} extends ParentClass & NativeClass", v.name))
            .collect::<Vec<_>>()
            .join(", ");

        if_else!(generics != "", format!("<{}>", generics), "".into())
    }

    /// Get generics
    pub fn generics(&self) -> String {
        let generics = self
            .generics
            .iter()
            .map(|v| v.name.to_owned())
            .collect::<Vec<_>>()
            .join(", ");

        if_else!(generics != "", format!("<{}>", generics), "".into())
    }
}