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
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
use std::ptr;
use std::ops::Deref;
use log::trace;
use crate::TryIntoJs;
use crate::JSValue;
use crate::sys::{napi_value, napi_ref, napi_env};
use crate::val::JsEnv;
use crate::NjError;
pub struct ArrayBuffer {
data: Vec<u8>,
}
use std::fmt;
use std::fmt::Debug;
impl Debug for ArrayBuffer {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.write_fmt(format_args!("ArrayBuffer len: {}", self.data.len()))
}
}
impl ArrayBuffer {
pub fn new(data: Vec<u8>) -> Self {
Self { data }
}
extern "C" fn finalize_buffer(
_env: napi_env,
_finalize_data: *mut ::std::os::raw::c_void,
finalize_hint: *mut ::std::os::raw::c_void,
) {
trace!("finalize array buffer");
unsafe {
let ptr: *mut Vec<u8> = finalize_hint as *mut Vec<u8>;
let _rust = Box::from_raw(ptr);
}
}
}
impl TryIntoJs for ArrayBuffer {
fn try_to_js(self, js_env: &JsEnv) -> Result<napi_value, NjError> {
let len = self.data.len();
let box_data = Box::new(self.data);
let mut napi_buffer = ptr::null_mut();
let data_buffer = box_data.as_ptr();
let data_box_ptr = Box::into_raw(box_data) as *mut core::ffi::c_void;
crate::napi_call_result!(crate::sys::napi_create_external_arraybuffer(
js_env.inner(),
data_buffer as *mut core::ffi::c_void,
len,
Some(Self::finalize_buffer),
data_box_ptr,
&mut napi_buffer
))?;
Ok(napi_buffer)
}
}
impl<'a> JSValue<'a> for &'a [u8] {
fn convert_to_rust(env: &'a JsEnv, js_value: napi_value) -> Result<Self, NjError> {
if !env.is_buffer(js_value)? {
return Err(NjError::InvalidType(
"Buffer".to_owned(),
env.value_type_string(js_value)?.to_owned(),
));
}
let buffer = env.get_buffer_info(js_value)?;
Ok(buffer)
}
}
pub struct JSArrayBuffer {
env: JsEnv,
napi_ref: napi_ref,
buffer: &'static [u8],
}
unsafe impl Send for JSArrayBuffer {}
impl JSArrayBuffer {
pub fn as_bytes(&self) -> &[u8] {
&self.buffer
}
}
impl JSValue<'_> for JSArrayBuffer {
fn convert_to_rust(env: &JsEnv, napi_value: napi_value) -> Result<Self, NjError> {
use std::mem::transmute;
let napi_ref = env.create_reference(napi_value, 1)?;
let buffer: &'static [u8] =
unsafe { transmute::<&[u8], &'static [u8]>(env.convert_to_rust(napi_value)?) };
Ok(Self {
env: *env,
napi_ref,
buffer,
})
}
}
impl Drop for JSArrayBuffer {
fn drop(&mut self) {
self.env
.delete_reference(self.napi_ref)
.expect("reference can't be deleted to array buf");
}
}
impl Deref for JSArrayBuffer {
type Target = [u8];
fn deref(&self) -> &Self::Target {
&self.buffer
}
}