edon 0.0.27

Library embedding Nodejs (libnode) within Rust
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

use std::ptr;

use libnode_sys;

use crate::napi::bindgen_runtime::FromNapiValue;
use crate::napi::bindgen_runtime::TypeName;
use crate::napi::check_status;
use crate::napi::Either;
use crate::napi::Env;
use crate::napi::Error;
use crate::napi::JsUndefined;
use crate::napi::NapiValue;
use crate::napi::Result;
use crate::napi::Status;

/// Function call context
pub struct CallContext<'env> {
  pub env: &'env mut Env,
  raw_this: libnode_sys::napi_value,
  callback_info: libnode_sys::napi_callback_info,
  args: &'env [libnode_sys::napi_value],
  /// arguments.length
  pub length: usize,
}

impl<'env> CallContext<'env> {
  /// The number of N-api obtained values. In practice this is the numeric
  /// parameter provided to the `#[js_function(arg_len)]` macro.
  ///
  /// As a comparison, the (arguments) `.length` represents the actual number
  /// of arguments given at a specific function call.
  ///
  /// If `.length < .arg_len`, then the elements in the `length .. arg_len`
  /// range are just `JsUndefined`s.
  ///
  /// If `.length > .arg_len`, then truncation has happened and some args have
  /// been lost.
  fn arg_len(&self) -> usize {
    self.args.len()
  }

  pub fn new(
    env: &'env mut Env,
    callback_info: libnode_sys::napi_callback_info,
    raw_this: libnode_sys::napi_value,
    args: &'env [libnode_sys::napi_value],
    length: usize,
  ) -> Self {
    Self {
      env,
      raw_this,
      callback_info,
      args,
      length,
    }
  }

  pub fn get<ArgType: FromNapiValue>(
    &self,
    index: usize,
  ) -> Result<ArgType> {
    if index >= self.arg_len() {
      Err(Error::new(
        Status::GenericFailure,
        "Arguments index out of range".to_owned(),
      ))
    } else {
      unsafe { ArgType::from_napi_value(self.env.0, self.args[index]) }
    }
  }

  pub fn try_get<ArgType: NapiValue + TypeName + FromNapiValue>(
    &self,
    index: usize,
  ) -> Result<Either<ArgType, JsUndefined>> {
    if index >= self.arg_len() {
      Err(Error::new(
        Status::GenericFailure,
        "Arguments index out of range".to_owned(),
      ))
    } else if index < self.length {
      unsafe { ArgType::from_raw(self.env.0, self.args[index]) }.map(Either::A)
    } else {
      self.env.get_undefined().map(Either::B)
    }
  }

  pub fn get_all(&self) -> Vec<crate::napi::JsUnknown> {
    /* (0 .. self.arg_len()).map(|i| self.get(i).unwrap()).collect() */
    self
      .args
      .iter()
      .map(|&raw| unsafe { crate::napi::JsUnknown::from_raw_unchecked(self.env.0, raw) })
      .collect()
  }

  pub fn get_new_target<V>(&self) -> Result<V>
  where
    V: NapiValue,
  {
    let mut value = ptr::null_mut();
    check_status!(unsafe {
      libnode_sys::napi_get_new_target(self.env.0, self.callback_info, &mut value)
    })?;
    unsafe { V::from_raw(self.env.0, value) }
  }

  pub fn this<T: NapiValue>(&self) -> Result<T> {
    unsafe { T::from_raw(self.env.0, self.raw_this) }
  }

  pub fn this_unchecked<T: NapiValue>(&self) -> T {
    unsafe { T::from_raw_unchecked(self.env.0, self.raw_this) }
  }
}