Struct Execution 

pub struct Execution<'a> { /* private fields */ }

A borrowed aggregate account and original parser-session work ceiling.

Obtain this from crate::Reader::execution. Copies allocate nothing and acquire no shared ownership. Scratch storage and work use the reader’s current account; rebinding the account never resets the parser ceiling.

A parser-bound allocation cannot survive its borrowed owner:

use std::sync::Arc;
use structured_asn1::{Parser, memory::{Memory, MemoryAccount, Work}};
let mut scratch;
{
    let parser = Parser::ber(Memory::new(Arc::new(MemoryAccount::new(1024, 1024))));
    let reader = parser.read(&[], 0).unwrap();
    scratch = reader.execution().vector();
    scratch.try_push(42_u8).unwrap();
}
drop(scratch);

Trait Implementations

impl<'a> Clone for Execution<'a>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'a> Copy for Execution<'a>

impl<'a> Debug for Execution<'a>

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

Formats the value using the given formatter.

impl Work for Execution<'_>

type Retained = Memory

Storage ownership retained by the allocator independently of borrowed work.

fn retain_storage(&self) -> Memory

Keeps an allocation’s account alive even if its collection is forgotten. Owned Memory already holds that account; borrowed Execution supplies one owning handle per collection without allocating a new account.

fn into_storage_owner(self, retained: Memory) -> Memory

Moves the existing account owner when finishing independently owned storage. The sealed implementations preserve the account without cloning it.

fn with_storage_owner(&self, memory: Memory) -> (Self, Memory)

Attaches current work while moving an existing same-account owner. The caller verifies account identity before transferring storage.

fn memory(&self) -> &Memory

The account retaining allocated capacity.

fn charge_work(&self, amount: u64) -> Result<(), MemoryError>

Admits work before execution, against every applicable ceiling.

fn vector<T>(&self) -> OwnedVec<T, Self>

Creates empty accounted scratch retaining this execution boundary.

fn map<K: HashWork, V>(&self) -> OwnedMap<K, V, Self>

Creates a bounded scratch map in this storage and execution domain. Hash/probes, table growth and value movement retain the same ceilings.