Struct neon::handle::Handle

#[repr(transparent)]
pub struct Handle<'a, T: Managed + '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

Trait Implementations

impl<'a, T: Managed> Clone for Handle<'a, T>

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'a, T: Debug + Managed + 'a> Debug for Handle<'a, T>

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

Formats the value using the given formatter.

impl<'a, T: Managed> Deref for Handle<'a, T>

type Target = T

The resulting type after dereferencing.

fn deref(&self) -> &T

Dereferences the value.

impl<'a, T: Managed> DerefMut for Handle<'a, T>

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

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 Local,
    obj: Local
) -> bool

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

impl<'a, T: Managed> Copy for Handle<'a, T>