Struct Budget 

pub struct Budget {
    pub limits: RasterLimits,
    /* private fields */
}

Mutable admission counters for one bounded geometry or rendering operation. Callers release transient payloads from live_bytes; work is never refunded.

Fields

limits: RasterLimits

Immutable allowances used by subsequent admission checks.

Implementations

impl Budget

pub fn new( size: PixelSize, limits: RasterLimits, ) -> Result<Self, ValidationError>

Creates empty counters after checking positive allowances and pixel count.

pub fn resume( limits: RasterLimits, live_bytes: u64, peak_bytes: u64, work: u64, ) -> Self

Resumes counters recorded by an earlier planning pass over the same limits.

The caller vouches that live_bytes, peak_bytes and work already passed admission against limits; nothing is re-checked.

pub fn live_bytes(&self) -> u64

Current logical payload bytes, excluding allocation capacity and overhead.

pub fn peak_bytes(&self) -> u64

Highest admitted live-byte total observed by this operation.

pub fn work_done(&self) -> u64

Cumulative admitted algorithm work units, not elapsed time.

pub fn release(&mut self, amount: u64)

Returns transient payload previously admitted with Self::bytes; the peak is kept.

Releasing more than is live is a caller bug and saturates at zero rather than wrapping.

pub fn reset_peak(&mut self) -> u64

Restarts peak tracking at the current live bytes and returns the previous peak.

Use it to measure one nested operation, then call Self::merge_peak with the returned value so the enclosing operation’s peak is not lost.

pub fn merge_peak(&mut self, peak: u64)

Raises the peak to at least peak, for example after Self::reset_peak.

pub fn set_live_bytes(&mut self, live_bytes: u64)

Replaces the live-byte count with an externally measured total, raising the peak if needed.

pub fn bytes(&mut self, amount: u64, path: &str) -> Result<(), ValidationError>

Admits additional live payload and updates the peak; failure leaves counters unchanged.

pub fn work(&mut self, amount: u64, path: &str) -> Result<(), ValidationError>

Admits cumulative work before execution; failure leaves the counter unchanged.

pub fn push<Value>( &mut self, values: &mut Vec<Value>, value: Value, path: &str, ) -> Result<(), ValidationError>

Charges one element’s logical bytes before fallibly reserving and appending. An allocation failure retains the admission charge; discard the partial operation.