rsbind_core/java/ty/
vec_byte.rs

1use proc_macro2::TokenStream;
2use rstgen::{Java, Tokens};
3
4use crate::ast::types::{AstBaseType, AstType};
5use crate::base::lang::{Convertible, Direction};
6use crate::java::types::JavaType;
7
8pub(crate) struct VecByte {
9    pub(crate) ty: AstType,
10}
11
12impl<'a> Convertible<Java<'a>> for VecByte {
13    fn native_to_transferable(
14        &self,
15        origin: String,
16        _direction: Direction,
17    ) -> Tokens<'static, Java<'a>> {
18        toks!(origin)
19    }
20
21    fn transferable_to_native(
22        &self,
23        origin: String,
24        _direction: Direction,
25    ) -> Tokens<'static, Java<'a>> {
26        toks!(origin)
27    }
28
29    fn rust_to_transferable(&self, origin: TokenStream, _direction: Direction) -> TokenStream {
30        match self.ty.clone() {
31            AstType::Vec(AstBaseType::Byte(ref base)) => {
32                if base.contains("i8") {
33                    quote! {{
34                        let slice = #origin.as_slice();
35                        let converted = unsafe {
36                            std::mem::transmute::<&[i8], &[u8]>(slice)
37                        };
38                        env.byte_array_from_slice(converted).unwrap()
39                    }}
40                } else {
41                    quote! {
42                        env.byte_array_from_slice(&#origin).unwrap()
43                    }
44                }
45            }
46            _ => {
47                quote! {}
48            }
49        }
50    }
51
52    fn transferable_to_rust(&self, origin: TokenStream, direction: Direction) -> TokenStream {
53        let buffer_get = match direction {
54            Direction::Down => {
55                quote! {}
56            }
57            Direction::Up => {
58                quote! {
59                    let #origin = match #origin {
60                        Ok(JValue::Object(value)) => {
61                            value.into_inner() as jbyteArray
62                        }
63                        _ => panic!("Wrong vec byte type.")
64                    };
65                }
66            }
67        };
68
69        match self.ty.clone() {
70            AstType::Vec(AstBaseType::Byte(ref base)) => {
71                if base.contains("i8") {
72                    quote! {{
73                        #buffer_get
74                        let mut byte_array = env.convert_byte_array(#origin).unwrap();
75                        let mut_ptr = byte_array.as_mut_ptr();
76                        let len = byte_array.len();
77                        let cap = byte_array.capacity();
78                        unsafe {
79                            std::mem::forget(byte_array);
80                            Vec::from_raw_parts(mut_ptr as (* mut i8), len, cap)
81                        }
82                    }}
83                } else {
84                    quote! {{
85                        #buffer_get
86                        env.convert_byte_array(#origin).unwrap()
87                    }}
88                }
89            }
90            _ => {
91                quote! {}
92            }
93        }
94    }
95
96    fn native_type(&self) -> Java<'a> {
97        JavaType::new(AstType::Byte("i8".to_string())).to_array()
98    }
99
100    fn native_transferable_type(&self, _direction: Direction) -> Java<'a> {
101        JavaType::new(AstType::Byte("i8".to_string())).to_array()
102    }
103
104    fn rust_transferable_type(&self, _direction: Direction) -> TokenStream {
105        quote! {jbyteArray}
106    }
107
108    fn quote_common_in_bridge(&self) -> TokenStream {
109        quote! {}
110    }
111
112    fn quote_common_in_native(&self) -> Tokens<'static, Java<'a>> {
113        Tokens::new()
114    }
115
116    fn quote_in_common_rs(&self) -> TokenStream {
117        quote! {}
118    }
119}
rsbind_core/java/ty/vec_byte.rs

rsbind_core/java/ty/
vec_byte.rs
