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 work_remaining(&self) -> usize

The largest amount Work::charge_work would admit now, across every ceiling it checks, without reserving it.

fn read_scoped_source<'source: 'operation, 'operation>( &'operation self, parser: &'source Parser, data: &'source [u8], base: u64, encoding: Encoding, depth: u32, ) -> Result<ScopedReader<'source, 'operation>>

Opens original input while borrowing this operation only for decoding. Parsed elements and scalar views retain the longer original input lifetime; no result needs to keep a completed operation alive merely because it borrows input. Source and current ceilings still apply to every read, scratch allocation and copy before that work. A cursor itself cannot escape a local operation:

fn read_nested<'source>( &self, parser: &'source Parser, data: &'source [u8], base: u64, encoding: Encoding, outer: u32, ) -> Result<Reader<'source>>

where Self: 'source,

Opens original nested bytes without discarding this execution boundary. Memory retains its existing source-plus-aggregate admission; Execution additionally preserves the current root operation before any decode. Source parser/data/base/encoding and actual outer + 1 depth remain original. A transition replaces a previous foreign source ceiling, never the operation owner. A fresh document uses depth zero through Work::read_source, rather than inventing a nested carrier level.

fn read_source<'source>( &self, parser: &'source Parser, data: &'source [u8], base: u64, encoding: Encoding, depth: u32, ) -> Result<Reader<'source>>

where Self: 'source,

Opens an original source window at its actual ASN.1 depth.

fn read_scoped_nested<'source: 'operation, 'operation>( &'operation self, parser: &'source Parser, data: &'source [u8], base: u64, encoding: Encoding, outer: u32, ) -> Result<ScopedReader<'source, 'operation>>

Nested form of Work::read_scoped_source, retaining actual outer+1 depth. Only decoding borrows this operation; returned input views do not.

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.