Struct rquickjs::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 as Outlive<'js>>::Target<'static>>

where T: Outlive<'js>,

Save the value of an arbitrary type

pub fn restore<'js>( self, ctx: &Ctx<'js> ) -> Result<<T as Outlive<'static>>::Target<'js>, Error>

where T: Outlive<'static>,

Restore the value of an arbitrary type

Trait Implementations

impl<T> Clone for Persistent<T>

where T: Clone,

fn clone(&self) -> Persistent<T>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T> Debug for Persistent<T>

where T: Debug,

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

Formats the value using the given formatter.

impl<'js, T, R> FromJs<'js> for Persistent<R>

where R: Outlive<'static, Target<'js> = T>, T: Outlive<'js, Target<'static> = R> + FromJs<'js>,

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

impl<T> Hash for Persistent<T>

where T: Hash,

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, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<'js, T> IntoJs<'js> for Persistent<T>

where T: Outlive<'static>, <T as Outlive<'static>>::Target<'js>: IntoJs<'js>,

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

impl<T> PartialEq for Persistent<T>

where T: PartialEq,

fn eq(&self, other: &Persistent<T>) -> 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>

where T: Eq,

impl<T> StructuralPartialEq for Persistent<T>