Struct napi::JsStringUtf8

pub struct JsStringUtf8 { /* private fields */ }

Implementations

impl JsStringUtf8

pub fn as_str(&self) -> Result<&str>

Examples found in repository

src/js_values/string/utf8.rs (line 33)

  pub fn into_owned(self) -> Result<String> {
    Ok(self.as_str()?.to_owned())
  }

src/env.rs (line 1038)

  pub fn get_napi_version(&self) -> Result<u32> {
    let global = self.get_global()?;
    let process: JsObject = global.get_named_property("process")?;
    let versions: JsObject = process.get_named_property("versions")?;
    let napi_version: JsString = versions.get_named_property("napi")?;
    napi_version
      .into_utf8()?
      .as_str()?
      .parse()
      .map_err(|e| Error::new(Status::InvalidArg, format!("{}", e)))
  }

src/js_values/de.rs (line 41)

  fn deserialize_any<V>(self, visitor: V) -> Result<V::Value>
  where
    V: Visitor<'x>,
  {
    let js_value_type = type_of!(self.0.env, self.0.value)?;
    match js_value_type {
      ValueType::Null | ValueType::Undefined => visitor.visit_unit(),
      ValueType::Boolean => {
        let js_boolean = unsafe { JsBoolean::from_raw_unchecked(self.0.env, self.0.value) };
        visitor.visit_bool(js_boolean.get_value()?)
      }
      ValueType::Number => {
        let js_number: f64 =
          unsafe { JsNumber::from_raw_unchecked(self.0.env, self.0.value).try_into()? };
        if (js_number.trunc() - js_number).abs() < f64::EPSILON {
          visitor.visit_i64(js_number as i64)
        } else {
          visitor.visit_f64(js_number)
        }
      }
      ValueType::String => {
        let js_string = unsafe { JsString::from_raw_unchecked(self.0.env, self.0.value) };
        visitor.visit_str(js_string.into_utf8()?.as_str()?)
      }
      ValueType::Object => {
        let js_object = unsafe { JsObject::from_raw_unchecked(self.0.env, self.0.value) };
        if js_object.is_array()? {
          let mut deserializer =
            JsArrayAccess::new(&js_object, js_object.get_array_length_unchecked()?);
          visitor.visit_seq(&mut deserializer)
        } else if js_object.is_buffer()? {
          visitor.visit_bytes(&JsBufferValue::from_raw(self.0.env, self.0.value)?)
        } else {
          let mut deserializer = JsObjectAccess::new(&js_object)?;
          visitor.visit_map(&mut deserializer)
        }
      }
      #[cfg(feature = "napi6")]
      ValueType::BigInt => {
        let mut js_bigint = unsafe { JsBigInt::from_raw(self.0.env, self.0.value)? };
        let (signed, v, _loss) = js_bigint.get_u128()?;
        if signed {
          visitor.visit_i128(-(v as i128))
        } else {
          visitor.visit_u128(v)
        }
      }
      ValueType::External | ValueType::Function | ValueType::Symbol => Err(Error::new(
        Status::InvalidArg,
        format!("typeof {:?} value could not be deserialized", js_value_type),
      )),
      ValueType::Unknown => unreachable!(),
    }
  }

pub fn as_slice(&self) -> &[u8]

Examples found in repository

src/js_values/string/utf8.rs (line 37)

  pub fn take(self) -> Vec<u8> {
    self.as_slice().to_vec()
  }

pub fn len(&self) -> usize

pub fn is_empty(&self) -> bool

pub fn into_owned(self) -> Result<String>

Examples found in repository

src/js_values/string/utf8.rs (line 49)

  fn try_from(value: JsStringUtf8) -> Result<String> {
    value.into_owned()
  }

src/js_values/de.rs (line 112)

  fn deserialize_enum<V>(
    self,
    _name: &'static str,
    _variants: &'static [&'static str],
    visitor: V,
  ) -> Result<V::Value>
  where
    V: Visitor<'x>,
  {
    let js_value_type = type_of!(self.0.env, self.0.value)?;
    match js_value_type {
      ValueType::String => visitor.visit_enum(JsEnumAccess::new(
        unsafe { JsString::from_raw_unchecked(self.0.env, self.0.value) }
          .into_utf8()?
          .into_owned()?,
        None,
      )),
      ValueType::Object => {
        let js_object = unsafe { JsObject::from_raw_unchecked(self.0.env, self.0.value) };
        let properties = js_object.get_property_names()?;
        let property_len = properties.get_array_length_unchecked()?;
        if property_len != 1 {
          Err(Error::new(
            Status::InvalidArg,
            format!(
              "object key length: {}, can not deserialize to Enum",
              property_len
            ),
          ))
        } else {
          let key = properties.get_element::<JsString>(0)?;
          let value: JsUnknown = js_object.get_property(key)?;
          visitor.visit_enum(JsEnumAccess::new(
            key.into_utf8()?.into_owned()?,
            Some(&value.0),
          ))
        }
      }
      _ => Err(Error::new(
        Status::InvalidArg,
        format!(
          "{:?} type could not deserialize to Enum type",
          js_value_type
        ),
      )),
    }
  }

pub fn take(self) -> Vec<u8>

Examples found in repository

src/js_values/string/utf8.rs (line 55)

  fn from(value: JsStringUtf8) -> Self {
    value.take()
  }

pub fn into_value(self) -> JsString

Trait Implementations

impl From<JsStringUtf8> for Vec<u8>

fn from(value: JsStringUtf8) -> Self

Converts to this type from the input type.

impl TryFrom<JsStringUtf8> for String

type Error = Error

The type returned in the event of a conversion error.

fn try_from(value: JsStringUtf8) -> Result<String>

Performs the conversion.