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

fn drop(&mut self)

Executes the destructor for this type.

impl<'js, 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>

Available on crate feature classes only.

fn mark_refs(&self, marker: &RefsMarker)

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

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>