Struct Spend 

pub struct Spend {
    pub tokens: u64,
    pub minor_units: u64,
}

What one effect consumed.

Deliberately unit-agnostic: the engine never learns what a token is or which currency minor_units is in. It adds them up and compares them to a limit.

Fields

tokens: u64

Model tokens, or any other metered unit the deployment counts.

minor_units: u64

Money in minor units — cents, pence, whatever the deployment uses.

Integer rather than float: money that rounds differently on two machines is money that produces two different budget verdicts.

Unsigned, and that is a security property rather than tidiness. Every ceiling in this crate — a Budget, a TenantQuota, a StandingAuthority — is enforced by comparing an accumulated Spend against a limit. A negative amount reverses the accumulation, so a single one un-spends everything before it and the ceiling stops being one. That was reachable while this was an i64: a €500 standing authority could be drawn to zero, drawn again for −€400, and then drawn for a further €400 — €900 against a €500 mandate, with every check passing. Refusing negatives in each of the three enforcement paths would have been three places to remember; making the state unrepresentable is none.

A refund or a credit is therefore not a Spend. It is a new authorization, which is what leaves both decisions on the record.

Implementations

impl Spend

pub const ZERO: Self

Nothing consumed.

pub const fn tokens(n: u64) -> Self

pub const fn money(minor_units: u64) -> Self

pub const fn is_free_ref(v: &Self) -> bool

By-reference form, for skip_serializing_if.

One predicate under one name. Two spellings of “did this cost anything” is two places for the answer to drift, and the by-reference form exists only because skip_serializing_if hands out a reference.

pub const fn is_free(self) -> bool

Whether this cost nothing at all.

pub fn plus(self, other: Self) -> Self

Saturating so a runaway meter cannot wrap into a smaller number and silently re-open a budget that was already blown.

Trait Implementations

impl AddAssign for Spend

fn add_assign(&mut self, rhs: Self)

Performs the += operation.

impl Clone for Spend

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for Spend

impl Debug for Spend

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

Formats the value using the given formatter.

impl Default for Spend

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Spend

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for Spend

What it cost, in a sentence a person reads.

This type reaches operators through refusals — a standing authority short of what a draw asked for names both amounts — where {:?} puts Rust syntax in the middle of an English sentence. A zero is still printed: it says the other dimension was unspent, where omitting it leaves a reader to guess whether it was unmetered.

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

Formats the value using the given formatter.

impl Eq for Spend

impl PartialEq for Spend

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

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl Serialize for Spend

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for Spend