feat(napi): implement type specialization methods for NapiAny

Author: aqrln

napi/src/result.rs

@@ -6,6 +6,7 @@ use std::ptr;
 use env::NapiEnv;
 use sys::{napi_create_error, napi_create_range_error, napi_create_type_error,
           napi_status, napi_value};
+use value::{NapiString, NapiValue};
 
 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
 pub enum NapiErrorKind {
@@ -108,13 +109,13 @@ impl Display for NapiError {
 
 macro_rules! error_constructor {
     ($name:ident => $napi_fn_name:ident) => {
-        pub fn $name(env: &NapiEnv, message: napi_value) -> NapiError {
+        pub fn $name(env: &NapiEnv, message: &NapiString) -> NapiError {
             let mut exception = ptr::null_mut();
             let status = unsafe {
                 $napi_fn_name(
                     env.as_sys_env(),
                     ptr::null_mut(),
-                    message,
+                    message.as_sys_value(),
                     &mut exception,
                 )
             };

napi/src/value/any.rs

@@ -1,10 +1,12 @@
 use std::ptr;
 
 use env::NapiEnv;
-use result::NapiResult;
+use result::{NapiError, NapiResult};
 use sys;
 
-use super::NapiValue;
+use super::{NapiArray, NapiBoolean, NapiNull, NapiNumber, NapiObject,
+            NapiString, NapiUndefined, NapiValue, NapiValueInternal,
+            NapiValueType};
 
 #[derive(Clone, Copy, Debug)]
 pub struct NapiAny<'a> {
@@ -25,6 +27,91 @@ impl<'a> NapiAny<'a> {
     pub fn with_value(env: &'a NapiEnv, value: sys::napi_value) -> Self {
         Self { env, value }
     }
+
+    pub fn as_undefined(&self) -> NapiResult<NapiUndefined<'a>> {
+        match self.value_type()? {
+            NapiValueType::Undefined => {
+                Ok(NapiUndefined::construct(self.env(), self.as_sys_value()))
+            }
+            _ => Err(NapiError::type_error(
+                self.env(),
+                &NapiString::from_str(self.env(), "undefined expected")?,
+            )),
+        }
+    }
+
+    pub fn as_null(&self) -> NapiResult<NapiNull<'a>> {
+        match self.value_type()? {
+            NapiValueType::Null => {
+                Ok(NapiNull::construct(self.env(), self.as_sys_value()))
+            }
+            _ => Err(NapiError::type_error(
+                self.env(),
+                &NapiString::from_str(self.env(), "null expected")?,
+            )),
+        }
+    }
+
+    pub fn as_boolean(&self) -> NapiResult<NapiBoolean<'a>> {
+        match self.value_type()? {
+            NapiValueType::Boolean => {
+                Ok(NapiBoolean::construct(self.env(), self.as_sys_value()))
+            }
+            _ => Err(NapiError::type_error(
+                self.env(),
+                &NapiString::from_str(self.env(), "boolean expected")?,
+            )),
+        }
+    }
+
+    pub fn as_number(&self) -> NapiResult<NapiNumber<'a>> {
+        match self.value_type()? {
+            NapiValueType::Number => {
+                Ok(NapiNumber::construct(self.env(), self.as_sys_value()))
+            }
+            _ => Err(NapiError::type_error(
+                self.env(),
+                &NapiString::from_str(self.env(), "number expected")?,
+            )),
+        }
+    }
+
+    pub fn as_string(&self) -> NapiResult<NapiString<'a>> {
+        match self.value_type()? {
+            NapiValueType::String => {
+                Ok(NapiString::construct(self.env(), self.as_sys_value()))
+            }
+            _ => Err(NapiError::type_error(
+                self.env(),
+                &NapiString::from_str(self.env(), "string expected")?,
+            )),
+        }
+    }
+
+    pub fn as_object(&self) -> NapiResult<NapiObject<'a>> {
+        match self.value_type()? {
+            NapiValueType::Object |
+            NapiValueType::String |
+            NapiValueType::Function => {
+                Ok(NapiObject::construct(self.env(), self.as_sys_value()))
+            }
+            _ => Err(NapiError::type_error(
+                self.env(),
+                &NapiString::from_str(self.env(), "object expected")?,
+            )),
+        }
+    }
+
+    pub fn as_array(&self) -> NapiResult<NapiArray<'a>> {
+        if self.is_array()? {
+            Ok(NapiArray::construct(self.env(), self.as_sys_value()))
+        } else {
+            Err(NapiError::type_error(
+                self.env(),
+                &NapiString::from_str(self.env(), "array expected")?,
+            ))
+        }
+    }
 }
 
 impl<'a> NapiValue<'a> for NapiAny<'a> {

napi/src/value/null.rs

@@ -4,7 +4,7 @@ use env::NapiEnv;
 use result::NapiResult;
 use sys;
 
-use super::NapiValue;
+use super::{NapiValue, NapiValueInternal};
 
 #[derive(Clone, Copy, Debug)]
 pub struct NapiNull<'a> {
@@ -32,3 +32,9 @@ impl<'a> NapiValue<'a> for NapiNull<'a> {
         self.env
     }
 }
+
+impl<'a> NapiValueInternal<'a> for NapiNull<'a> {
+    fn construct(env: &'a NapiEnv, value: sys::napi_value) -> Self {
+        Self { env, value }
+    }
+}

napi/src/value/undefined.rs

@@ -4,7 +4,7 @@ use env::NapiEnv;
 use result::NapiResult;
 use sys;
 
-use super::NapiValue;
+use super::{NapiValue, NapiValueInternal};
 
 #[derive(Clone, Copy, Debug)]
 pub struct NapiUndefined<'a> {
@@ -32,3 +32,9 @@ impl<'a> NapiValue<'a> for NapiUndefined<'a> {
         self.env
     }
 }
+
+impl<'a> NapiValueInternal<'a> for NapiUndefined<'a> {
+    fn construct(env: &'a NapiEnv, value: sys::napi_value) -> Self {
+        Self { env, value }
+    }
+}