napi 3.10.3

N-API bindings
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
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

use std::{ffi::c_void, ptr};

use super::TypeName;
use crate::{check_status, sys, Error, JsError, Result, Status};

#[doc(hidden)]
pub type ClassAccessorGetter = unsafe fn(sys::napi_env, sys::napi_value) -> Result<sys::napi_value>;

#[doc(hidden)]
pub type ClassAccessorSetter =
  unsafe fn(sys::napi_env, sys::napi_value, sys::napi_value) -> Result<sys::napi_value>;

#[doc(hidden)]
pub struct ClassAccessorDescriptor {
  pub getter: Option<ClassAccessorGetter>,
  pub setter: Option<ClassAccessorSetter>,
}

#[doc(hidden)]
pub struct ClassAccessorCallbackInfo<const N: usize> {
  env: sys::napi_env,
  this: sys::napi_value,
  args: [sys::napi_value; N],
}

impl<const N: usize> ClassAccessorCallbackInfo<N> {
  #[doc(hidden)]
  #[inline]
  pub fn new(env: sys::napi_env, this: sys::napi_value, args: [sys::napi_value; N]) -> Self {
    Self { env, this, args }
  }

  #[doc(hidden)]
  #[inline]
  pub fn get_arg(&self, index: usize) -> sys::napi_value {
    self.args[index]
  }

  #[doc(hidden)]
  #[inline]
  pub fn this(&self) -> sys::napi_value {
    self.this
  }

  #[doc(hidden)]
  #[inline]
  pub unsafe fn unwrap_raw<T>(&mut self) -> Result<*mut T>
  where
    T: TypeName,
  {
    unsafe { class_accessor_unwrap_this::<T>(self.env, self.this) }
  }
}

#[doc(hidden)]
#[inline]
pub unsafe fn class_accessor_unwrap_this<T>(
  env: sys::napi_env,
  this: sys::napi_value,
) -> Result<*mut T>
where
  T: TypeName,
{
  let mut wrapped_val: *mut c_void = ptr::null_mut();

  check_status!(
    unsafe { sys::napi_unwrap(env, this, &mut wrapped_val) },
    "Failed to unwrap exclusive reference of `{}` type from napi value",
    T::type_name(),
  )?;

  Ok(wrapped_val.cast())
}

#[doc(hidden)]
pub unsafe extern "C" fn class_getter_trampoline(
  env: sys::napi_env,
  cb_info: sys::napi_callback_info,
) -> sys::napi_value {
  let mut this = ptr::null_mut();
  let mut data = ptr::null_mut();

  check_status!(
    unsafe { sys::napi_get_cb_info(env, cb_info, &mut 0, ptr::null_mut(), &mut this, &mut data,) },
    "napi_get_cb_info failed"
  )
  .and_then(|_| {
    let descriptor = unsafe { (data as *const ClassAccessorDescriptor).as_ref() }
      .ok_or_else(|| Error::new(Status::InvalidArg, "Missing class accessor descriptor"))?;
    let getter = descriptor.getter.ok_or_else(|| {
      Error::new(
        Status::InvalidArg,
        "Missing class accessor getter descriptor",
      )
    })?;
    unsafe { getter(env, this) }
  })
  .unwrap_or_else(|e| {
    unsafe { JsError::from(e).throw_into(env) };
    ptr::null_mut()
  })
}

#[doc(hidden)]
pub unsafe extern "C" fn class_setter_trampoline(
  env: sys::napi_env,
  cb_info: sys::napi_callback_info,
) -> sys::napi_value {
  let mut argc = 1;
  let mut args = [ptr::null_mut()];
  let mut this = ptr::null_mut();
  let mut data = ptr::null_mut();

  check_status!(
    unsafe {
      sys::napi_get_cb_info(
        env,
        cb_info,
        &mut argc,
        args.as_mut_ptr(),
        &mut this,
        &mut data,
      )
    },
    "napi_get_cb_info failed"
  )
  .and_then(|_| {
    if argc == 0 {
      return Err(Error::new(
        Status::InvalidArg,
        "Missing argument in property setter",
      ));
    }
    let descriptor = unsafe { (data as *const ClassAccessorDescriptor).as_ref() }
      .ok_or_else(|| Error::new(Status::InvalidArg, "Missing class accessor descriptor"))?;
    let setter = descriptor.setter.ok_or_else(|| {
      Error::new(
        Status::InvalidArg,
        "Missing class accessor setter descriptor",
      )
    })?;
    unsafe { setter(env, this, args[0]) }
  })
  .unwrap_or_else(|e| {
    unsafe { JsError::from(e).throw_into(env) };
    ptr::null_mut()
  })
}