use crate::napi::*;
use crate::value::{self, Result, Thrown};
use std::ffi::c_void;
unsafe extern "C" fn finalize<T>(_env: napi_env, data: *mut c_void, _hint: *mut c_void) {
if !data.is_null() {
drop(unsafe { Box::from_raw(data as *mut T) });
}
}
pub fn wrap<T: 'static>(
env: napi_env,
value_of: T,
methods: &[(&'static std::ffi::CStr, napi_callback)],
) -> Result<napi_value> {
wrap_with(env, value_of, methods, &[])
}
pub fn wrap_with<T: 'static>(
env: napi_env,
value_of: T,
methods: &[(&'static std::ffi::CStr, napi_callback)],
getters: &[(&'static std::ffi::CStr, napi_callback)],
) -> Result<napi_value> {
let object = value::object(env)?;
let boxed = Box::into_raw(Box::new(value_of)) as *mut c_void;
value::ok(
unsafe {
napi_wrap(
env,
object,
boxed,
Some(finalize::<T>),
std::ptr::null_mut(),
std::ptr::null_mut(),
)
},
"napi_wrap",
)
.inspect_err(|_| {
drop(unsafe { Box::from_raw(boxed as *mut T) });
})?;
for (name, callback) in methods {
let mut function = std::ptr::null_mut();
value::ok(
unsafe {
napi_create_function(
env,
name.as_ptr(),
usize::MAX,
*callback,
std::ptr::null_mut(),
&mut function,
)
},
"napi_create_function",
)?;
let name = name
.to_str()
.map_err(|_| Thrown("a method name was not UTF-8".into()))?;
value::set(env, object, name, function)?;
}
for (name, getter) in getters {
let descriptor = napi_property_descriptor {
utf8name: name.as_ptr(),
name: std::ptr::null_mut(),
method: None,
getter: Some(*getter),
setter: None,
value: std::ptr::null_mut(),
attributes: 2,
data: std::ptr::null_mut(),
};
value::ok(
unsafe { napi_define_properties(env, object, 1, &descriptor) },
"napi_define_properties",
)?;
}
Ok(object)
}
pub unsafe fn unwrap<T: 'static>(env: napi_env, object: napi_value) -> Result<&'static T> {
let mut data: *mut c_void = std::ptr::null_mut();
value::ok(
unsafe { napi_unwrap(env, object, &mut data) },
"napi_unwrap",
)?;
if data.is_null() {
return Err(Thrown(
"this method was called on something that is not the object it belongs to".into(),
));
}
Ok(unsafe { &*(data as *const T) })
}
pub unsafe fn this_and_args(
env: napi_env,
info: napi_callback_info,
count: usize,
) -> Result<(napi_value, Vec<napi_value>)> {
let mut argc = count;
let mut argv = vec![std::ptr::null_mut(); count.max(1)];
let mut this = std::ptr::null_mut();
value::ok(
unsafe {
napi_get_cb_info(
env,
info,
&mut argc,
argv.as_mut_ptr(),
&mut this,
std::ptr::null_mut(),
)
},
"napi_get_cb_info",
)?;
argv.truncate(count);
Ok((this, argv))
}
pub struct Held {
reference: napi_ref,
}
unsafe impl Send for Held {}
unsafe impl Sync for Held {}
impl Held {
pub fn new(env: napi_env, value: napi_value) -> Result<Self> {
let mut reference = std::ptr::null_mut();
value::ok(
unsafe { napi_create_reference(env, value, 1, &mut reference) },
"napi_create_reference",
)?;
Ok(Self { reference })
}
pub unsafe fn get(&self, env: napi_env) -> Result<napi_value> {
let mut out = std::ptr::null_mut();
value::ok(
unsafe { napi_get_reference_value(env, self.reference, &mut out) },
"napi_get_reference_value",
)?;
Ok(out)
}
pub unsafe fn call(&self, env: napi_env, argument: napi_value) -> Result<()> {
let function = unsafe { self.get(env) }?;
let undefined = value::undefined(env)?;
let args = [argument];
value::ok(
unsafe {
napi_call_function(
env,
undefined,
function,
args.len(),
args.as_ptr(),
std::ptr::null_mut(),
)
},
"napi_call_function",
)
}
}
#[macro_export]
macro_rules! methods {
($($name:literal => $callback:path),* $(,)?) => {
&[$((
match std::ffi::CStr::from_bytes_with_nul(concat!($name, "\0").as_bytes()) {
Ok(s) => s,
Err(_) => panic!("a method name held a NUL"),
},
$callback as $crate::napi::napi_callback,
)),*]
};
}
#[cfg(test)]
mod tests {
#[test]
fn method_names_are_nul_terminated_at_compile_time() {
assert_eq!(c"readValue".to_bytes(), b"readValue");
assert_eq!(c"readValue".to_bytes_with_nul().last(), Some(&0));
}
#[test]
fn auto_length_is_the_sentinel_the_runtime_expects() {
const NAPI_AUTO_LENGTH: usize = usize::MAX;
assert_eq!(NAPI_AUTO_LENGTH, usize::MAX);
}
}