Struct rquickjs_core::Persistent

pub struct Persistent<T> { /* private fields */ }

The wrapper for JS values to keep it from GC

For example you can store JS functions for later use.

let func = ctx.with(|ctx| {
    Persistent::save(ctx, ctx.eval::<Function, _>("a => a + 1").unwrap())
});
let res: i32 = ctx.with(|ctx| {
    let func = func.clone().restore(ctx).unwrap();
    func.call((2,)).unwrap()
});
assert_eq!(res, 3);
let res: i32 = ctx.with(|ctx| {
    let func = func.restore(ctx).unwrap();
    func.call((0,)).unwrap()
});
assert_eq!(res, 1);

It is an error (Error::UnrelatedRuntime) to restore the Persistent in a context who isn’t part of the original Runtime.

NOTE: Be careful and ensure that no persistent links outlives the runtime, otherwise Runtime will abort the process when dropped.

Implementations

impl<T> Persistent<T>

pub fn save<'js>(ctx: Ctx<'js>, val: T) -> Persistent<T::Target> where
    T: AsRef<Value<'js>> + Outlive<'static>, 

Save the value of an arbitrary type

pub fn restore<'js>(self, ctx: Ctx<'js>) -> Result<T::Target> where
    T: Outlive<'js>,
    T::Target: FromJs<'js>, 

Restore the value of an arbitrary type

Trait Implementations

impl<T> Clone for Persistent<T>

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T> Debug for Persistent<T>

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

Formats the value using the given formatter.

impl<'t, T> Drop for Persistent<T>

fn drop(&mut self)

Executes the destructor for this type.

impl<'js, 't, T> FromJs<'js> for Persistent<T> where
    T: Outlive<'js>,
    T::Target: FromJs<'js> + IntoJs<'js>, 

fn from_js(ctx: Ctx<'js>, value: Value<'js>) -> Result<Persistent<T>>

impl<T> HasRefs for Persistent<T>

fn mark_refs(&self, marker: &RefsMarker)

Available on crate feature classes only.

impl<T> Hash for Persistent<T>

fn hash<H>(&self, state: &mut H) where
    H: Hasher, 

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H) where
    H: Hasher, 

Feeds a slice of this type into the given Hasher.

impl<'js, 't, T> IntoJs<'js> for Persistent<T> where
    T: Outlive<'t>, 

fn into_js(self, ctx: Ctx<'js>) -> Result<Value<'js>>

impl<T, S> PartialEq<Persistent<S>> for Persistent<T>

fn eq(&self, other: &Persistent<S>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T> Eq for Persistent<T>