Struct jlrs::memory::target::frame::AsyncGcFrame

pub struct AsyncGcFrame<'scope> { /* private fields */ }

A frame associated with an async scope.

The only difference between a GcFrame and an AsyncGcFrame is that the latter allows calling several async methods, most importantly those of CallAsync. An AsyncGcFrame can be (mutably) dereferenced as a GcFrame, so all methods of GcFrame are available to AsyncGcFrame.

Implementations

impl<'scope> AsyncGcFrame<'scope>

pub async fn async_scope<'nested, T, F, G>( &'nested mut self, func: F ) -> JlrsResult<T>

where T: 'scope, G: Future<Output = JlrsResult<T>>, F: FnOnce(AsyncGcFrame<'nested>) -> G,

An async version of GcFrame::scope.

The closure func must return an async block. Note that the returned value is required to live at least as long the current frame.

pub async unsafe fn relaxed_async_scope<'nested, T, F, G>( &'nested mut self, func: F ) -> JlrsResult<T>

where T: 'nested, G: Future<Output = JlrsResult<T>>, F: FnOnce(AsyncGcFrame<'nested>) -> G,

AsyncGcFrame::async_scope with less strict lifeitme bounds on the return value.

Safety: because this method only requires that the returned data lives at least as long as the borrow of self, it’s possible to return data rooted in that scope which you must not do.

Methods from Deref<Target = GcFrame<'scope>>

pub fn as_mut(&mut self) -> &mut Self

Returns a mutable reference to this frame.

pub fn reserve(&mut self, additional: usize)

Reserve capacity for at least additional roots.

pub fn borrow<'borrow>( &'borrow mut self ) -> BorrowedFrame<'borrow, 'scope, Self>

Borrow the current frame.

pub fn extended_target<'target, 'borrow, T>( &'borrow mut self, target: T ) -> ExtendedTarget<'target, 'scope, 'borrow, T>

where T: Target<'target>,

Borrow this frame as an ExtendedTarget with the provided target.

pub fn as_extended_target<'borrow>( &'borrow mut self ) -> ExtendedTarget<'scope, 'scope, 'borrow, Output<'scope>>

Borrow this frame as an ExtendedTarget with an Output that targets this frame.

pub fn n_roots(&self) -> usize

Returns the number of values rooted in this frame.

pub fn stack_size(&self) -> usize

Returns the number of values rooted in this frame.

pub fn output(&self) -> Output<'scope>

Returns an Output that targets the current frame.

pub fn reusable_slot(&self) -> ReusableSlot<'scope>

Returns a ReusableSlot that targets the current frame.

pub fn unrooted(&self) -> Unrooted<'scope>

Returns an Unrooted that targets the current frame.

pub fn scope<T, F>(&mut self, func: F) -> JlrsResult<T>

where for<'inner> F: FnOnce(GcFrame<'inner>) -> JlrsResult<T>,

Create a temporary scope and call func with that scope’s GcFrame.

Example:

julia
    .scope(|mut frame| {
        let output = frame.output();

        let _sum = frame.scope(|mut frame| {
            let i = Value::new(&mut frame, 1u64);
            let j = Value::new(&mut frame, 2u64);

            unsafe {
                Module::base(&frame)
                    .function(&mut frame, "+")?
                    .call2(output, i, j)
                    .into_jlrs_result()
            }
        })?;

        Ok(())
    })
    .unwrap();

Trait Implementations

impl<'scope> Deref for AsyncGcFrame<'scope>

type Target = GcFrame<'scope>

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<'scope> DerefMut for AsyncGcFrame<'scope>

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

impl<'target> Target<'target> for &mut AsyncGcFrame<'target>

fn unrooted(&self) -> Unrooted<'target>

Returns a new Unrooted.

fn local_scope<T, F, const M: usize>(&self, func: F) -> JlrsResult<T>

where for<'inner> F: FnOnce(LocalGcFrame<'inner, M>) -> JlrsResult<T>,

Create a new local scope and call func.

fn with_local_scope<T, F, const M: usize>(self, func: F) -> JlrsResult<T>

where for<'inner> F: FnOnce(Self, LocalGcFrame<'inner, M>) -> JlrsResult<T>,

Create a new local scope and call func.

fn into_extended_target<'borrow, 'current>( self, frame: &'borrow mut GcFrame<'current> ) -> ExtendedTarget<'target, 'current, 'borrow, Self>

Convert self into an ExtendedTarget.

fn into_extended_async_target<'borrow, 'current>( self, frame: &'borrow mut AsyncGcFrame<'current> ) -> ExtendedAsyncTarget<'target, 'current, 'borrow, Self>

Convert self into an ExtendedAsyncTarget.

impl<'target> Target<'target> for AsyncGcFrame<'target>

fn unrooted(&self) -> Unrooted<'target>

Returns a new Unrooted.

fn local_scope<T, F, const M: usize>(&self, func: F) -> JlrsResult<T>

where for<'inner> F: FnOnce(LocalGcFrame<'inner, M>) -> JlrsResult<T>,

Create a new local scope and call func.

fn with_local_scope<T, F, const M: usize>(self, func: F) -> JlrsResult<T>

where for<'inner> F: FnOnce(Self, LocalGcFrame<'inner, M>) -> JlrsResult<T>,

Create a new local scope and call func.

fn into_extended_target<'borrow, 'current>( self, frame: &'borrow mut GcFrame<'current> ) -> ExtendedTarget<'target, 'current, 'borrow, Self>

Convert self into an ExtendedTarget.

fn into_extended_async_target<'borrow, 'current>( self, frame: &'borrow mut AsyncGcFrame<'current> ) -> ExtendedAsyncTarget<'target, 'current, 'borrow, Self>

Convert self into an ExtendedAsyncTarget.

impl<'target> TargetType<'target> for &mut AsyncGcFrame<'target>

type Data<'data, T: Managed<'target, 'data>> = T

Type returned by functions that don’t catch Julia exceptions.

impl<'target> TargetType<'target> for AsyncGcFrame<'target>

type Data<'data, T: Managed<'target, 'data>> = T

Type returned by functions that don’t catch Julia exceptions.