Struct AllocatedMemory 

pub struct AllocatedMemory<'g> { /* private fields */ }

AllocatedMemory itself is needed when allocating memory on the Rust side; It is an RAII wrapper over memory allocated on the heap of the zygote clone via Scope::alloc; Automatically sends a Free request when going out of scope (Drop).

Important: Library has its own methods for working with memory - they are also needed, but only when we are not the creators of the memory region.

To work with raw addresses allocated by the C side (for example, strdup), use the Library methods directly.

'g is the lifetime of the ScopeGuard block of crate::ffi! in which it was created. Until it is 'static — the value physically cannot be returned from crate::ffi! outside.

Implementations

impl<'g> AllocatedMemory<'g>

pub const fn address(&self) -> usize

Returns the raw memory address of the allocation.

pub const fn length(&self) -> usize

Returns the size of the allocated memory block in bytes.

pub const fn asPointer(&self) -> Pointer

Wraps the address into a Pointer for FFI calls.

pub fn read(&self) -> Result<Vec<u8>, FFIError>

Reads the entire allocated memory block from the zygote as raw bytes.

pub fn write(&self, value: impl FfiArg) -> Result<(), FFIError>

Writes a value into the allocated memory block in the zygote.

pub fn readStruct<T: Pod + Zeroable>(&self) -> Result<T, FFIError>

Reads the allocated memory as a statically-typed C struct T.

T must be #[repr(C)] and implement Pod (plain old data) from bytemuck. The Pod bound is checked at compile time — if T has padding or non-POD fields, the code will simply refuse to compile instead of silently reading garbage.

This eliminates all manual byte parsing: the struct’s size and field layout are guaranteed correct by the type system rather than by manually calculated offsets.

pub fn writeStruct<T: Pod + Zeroable>(&self, value: &T) -> Result<(), FFIError>

Writes a statically-typed C struct T into the allocated memory buffer.

T must be #[repr(C)] and implement Pod from bytemuck.

The entire struct is serialized to bytes and written to the zygote’s memory.

Trait Implementations

impl<'g> Drop for AllocatedMemory<'g>

fn drop(&mut self)

Automatically frees the allocated memory in the zygote on scope exit.

fn pin_drop(self: Pin<&mut Self>)

🔬This is a nightly-only experimental API. (pin_ergonomics)

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.