pinar 0.1.0

Library to write node native modules with N-API
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


use std::rc::Rc;
use std::sync::Arc;
use std::os::raw::c_char;
use napi_sys::*;
use crate::prelude::*;
use crate::Result;

pub trait ToRust<R> {
    fn to_rust(&self) -> Result<R>;
}

impl<'e> ToRust<String> for JsString<'e>
{
    fn to_rust(&self) -> Result<String> {
        let len = self.len()?;
        let mut buffer: Vec<u8> = Vec::with_capacity(len + 1); // + '\0'
        let mut written = 0usize;
        unsafe {
            Status::result(napi_get_value_string_utf8(
                self.value.env(),
                self.value.get(),
                buffer.as_mut_ptr() as *mut c_char,
                len + 1,
                &mut written as *mut usize
            ))?;
            buffer.set_len(written);
            // It's probably safe to assume that it's valid ut8
            Ok(String::from_utf8_unchecked(buffer))
        }
    }
}

impl<'e> ToRust<i64> for JsNumber<'e> {
    fn to_rust(&self) -> Result<i64> {
        let mut number = 0i64;
        unsafe {
            Status::result(napi_get_value_int64(
                self.value.env(),
                self.value.get(),
                &mut number as *mut i64
            ))?;
        }
        Ok(number)
    }
}

impl<'e> ToRust<i32> for JsNumber<'e> {
    fn to_rust(&self) -> Result<i32> {
        let mut number = 0i32;
        unsafe {
            Status::result(napi_get_value_int32(
                self.value.env(),
                self.value.get(),
                &mut number as *mut i32
            ))?;
        }
        Ok(number)
    }
}

impl<'e> ToRust<u32> for JsNumber<'e> {
    fn to_rust(&self) -> Result<u32> {
        let mut number = 0u32;
        unsafe {
            Status::result(napi_get_value_uint32(
                self.value.env(),
                self.value.get(),
                &mut number as *mut u32
            ))?;
        }
        Ok(number)
    }
}

impl<'e> ToRust<f64> for JsNumber<'e> {
    fn to_rust(&self) -> Result<f64> {
        let mut number = 0f64;
        unsafe {
            Status::result(napi_get_value_double(
                self.value.env(),
                self.value.get(),
                &mut number as *mut f64
            ))?;
        }
        Ok(number)
    }
}

impl<'e> ToRust<bool> for JsBoolean<'e> {
    fn to_rust(&self) -> Result<bool> {
        let mut result = false;
        unsafe {
            Status::result(napi_get_value_bool(
                self.value.env(),
                self.value.get(),
                &mut result as *mut bool
            ))?;
        }
        Ok(result)
    }
}

impl<'e, T: 'static> ToRust<Arc<T>> for JsExternal<'e>
{
    fn to_rust(&self) -> Result<Arc<T>> {
        self.get_arc()
    }
}

impl<'e, T: 'static> ToRust<Rc<T>> for JsExternal<'e>
{
    fn to_rust(&self) -> Result<Rc<T>> {
        self.get_rc()
    }
}

impl<'e, T: 'static> ToRust<Box<T>> for JsExternal<'e>
{
    fn to_rust(&self) -> Result<Box<T>> {
        match self.take_box()? {
            Some(b) => Ok(b),
            _ => panic!("Extracting a box from a JsExternal that have
already been extracted. Use Option<Box<T>>")
        }
    }
}

impl<'e, T: 'static> ToRust<Option<Box<T>>> for JsExternal<'e> {
    fn to_rust(&self) -> Result<Option<Box<T>>> {
        self.take_box()
    }
}