Struct Handle

pub struct Handle<'a, V: Value + 'a> { /* private fields */ }

A handle to a JavaScript value that is owned by the JavaScript engine.

Implementations

impl<'a, T: Value> Handle<'a, T>

pub fn upcast<U: Value + SuperType<T>>(&self) -> Handle<'a, U>

Safely upcast a handle to a supertype.

This method does not require an execution context because it only copies a handle.

pub fn is_a<'b, U: Value, C: Context<'b>>(&self, cx: &mut C) -> bool

Tests whether this value is an instance of the given type.

Example:

let v: Handle<JsValue> = cx.number(17).upcast();
v.is_a::<JsString, _>(&mut cx); // false
v.is_a::<JsNumber, _>(&mut cx); // true
v.is_a::<JsValue, _>(&mut cx);  // true

pub fn downcast<'b, U: Value, C: Context<'b>>( &self, cx: &mut C, ) -> DowncastResult<'a, T, U>

Attempts to downcast a handle to another type, which may fail. A failure to downcast does not throw a JavaScript exception, so it’s OK to continue interacting with the JS engine if this method produces an Err result.

pub fn downcast_or_throw<'b, U: Value, C: Context<'b>>( &self, cx: &mut C, ) -> JsResult<'a, U>

Attempts to downcast a handle to another type, raising a JavaScript TypeError exception on failure. This method is a convenient shorthand, equivalent to self.downcast::<U>().or_throw::<C>(cx).

pub fn strict_equals<'b, U: Value, C: Context<'b>>( &self, cx: &mut C, other: Handle<'b, U>, ) -> bool

impl<'cx> Handle<'cx, JsArrayBuffer>

pub fn region<T: Binary>(&self, offset: usize, len: usize) -> Region<'cx, T>

Returns a Region representing a typed region of this buffer, starting at offset and containing len elements of type T.

The region is not checked for validity by this method. Regions are only validated when they are converted to typed arrays.

Example

let buf: Handle<JsArrayBuffer> = cx.argument(0)?;
let region = buf.region::<u32>(64, 8);
println!("offset={}, len={}, size={}", region.offset(), region.len(), region.size());

See the Region documentation for more information.

Trait Implementations

impl<'a, V: Value> Clone for Handle<'a, V>

fn clone(&self) -> Self

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<'a, V: Debug + Value + 'a> Debug for Handle<'a, V>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'a, V: Value> Deref for Handle<'a, V>

type Target = V

The resulting type after dereferencing.

fn deref(&self) -> &V

Dereferences the value.

impl<'a, V: Value> DerefMut for Handle<'a, V>

fn deref_mut(&mut self) -> &mut V

Mutably dereferences the value.

impl<'a, K: Value> PropertyKey for Handle<'a, K>

unsafe fn get_from<'c, C: Context<'c>>( self, cx: &mut C, out: &mut Value, obj: Value, ) -> bool

unsafe fn set_from<'c, C: Context<'c>>( self, cx: &mut C, out: &mut bool, obj: Value, val: Value, ) -> bool

impl<'a> ResultExt<Handle<'a, JsString>> for StringResult<'a>

fn or_throw<'b, C: Context<'b>>(self, cx: &mut C) -> JsResult<'a, JsString>

impl<'a, T: Value> ResultExt<Handle<'a, T>> for Result<Handle<'a, T>, DateError>

fn or_throw<'b, C: Context<'b>>(self, cx: &mut C) -> JsResult<'a, T>

Creates an Error on error

impl<'a, F: Value, T: Value> ResultExt<Handle<'a, T>> for DowncastResult<'a, F, T>

fn or_throw<'b, C: Context<'b>>(self, cx: &mut C) -> JsResult<'a, T>

impl<'a, 'b, T, E> ResultExt<Handle<'a, T>> for Result<Handle<'a, T>, Handle<'b, E>>

where T: Value, E: Value,

fn or_throw<'cx, C: Context<'cx>>(self, cx: &mut C) -> JsResult<'a, T>

impl<'cx, V> TryFromJs<'cx> for Handle<'cx, V>

where V: Value,

type Error = TypeExpected<V>

fn try_from_js( cx: &mut Cx<'cx>, v: Handle<'cx, JsValue>, ) -> NeonResult<Result<Self, Self::Error>>

Extract this Rust type from a JavaScript value

fn from_js(cx: &mut Cx<'cx>, v: Handle<'cx, JsValue>) -> NeonResult<Self>

Same as TryFromJs, but all errors are converted to JavaScript exceptions

impl<'cx, T> TryIntoJs<'cx> for Handle<'cx, T>

where T: Value,

type Value = T

The type of JavaScript value that will be created

fn try_into_js(self, _cx: &mut Cx<'cx>) -> JsResult<'cx, Self::Value>

Convert self into a JavaScript value

impl<'a, V: Value> Copy for Handle<'a, V>