Struct Memory 

pub struct Memory { /* private fields */ }

A shared storage domain retained by owned results.

Cloning this handle shares existing state and allocates no new block.

Implementations

impl Memory

pub fn new(account: Arc<MemoryAccount>) -> Self

Uses caller-supplied shared state; this constructor allocates nothing.

pub fn limit(&self) -> usize

The immutable allowance in bytes.

pub fn used(&self) -> usize

Currently reserved bytes, including pending allocations and growth peaks.

pub fn same_account(&self, other: &Self) -> bool

Whether two handles share exactly the same account, without allocation.

pub fn work_used(&self) -> usize

Cumulative work already admitted, including operations that later failed.

pub fn work_remaining(&self) -> usize

Currently available aggregate work units, without reserving them. Concurrent consumption can reduce this observation; every operation must still use Self::charge_work before execution.

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

Charges work before performing it; storage release never refunds work.

An amount unrepresentable on this target is refused before any work, preserving the existing u64 scanning API on 32-bit targets.

pub fn reserve(&self, bytes: usize) -> Result<MemoryReservation, MemoryError>

Reserves storage for an adapter-owned allocation before allocating it.

Keep the returned guard until after deallocation, including rollback on failure. Reserve the complete actual capacity; a growth must retain the old guard while admitting the replacement. This bridge does not allocate.

pub fn vector<T>(&self) -> OwnedVec<T>

An empty owned collection sharing this domain, without allocating storage.

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

An empty accounted hash map, without allocating storage.

pub fn string(&self) -> OwnedString

Empty accounted UTF-8 text, without allocating storage.

Trait Implementations

impl Clone for Memory

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Memory

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

Formats the value using the given formatter.

impl Work for Memory

type Retained = ()

Storage ownership retained by the allocator independently of borrowed work.

fn retain_storage(&self)

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, (): ()) -> 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, ())

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.