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<'static>>where T: Outlive<'js>,

Save the value of an arbitrary type

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

Restore the value of an arbitrary type

Trait Implementations

impl<T: Clone> 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>where T: Debug,

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

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>>

impl<T: Hash> Hash for Persistent<T>

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

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::Target<'js>: IntoJs<'js>,

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

impl<T: PartialEq> PartialEq<Persistent<T>> for Persistent<T>

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> Eq for Persistent<T>

impl<T> StructuralEq for Persistent<T>

impl<T> StructuralPartialEq for Persistent<T>