Struct BookedCost 

pub struct BookedCost {
    pub per_unit: Decimal,
    pub total: Decimal,
}

Payload of CostNumber::PerUnitFromTotal.

Carries both the per-unit value derived at booking time and the original {{ total }} cost so residual math can use the exact total (avoiding the division-then-multiplication precision loss that hits the rust_decimal 28-digit ceiling on long ledgers).

Fields

per_unit: Decimal

Per-unit cost, derived as total / |units| during booking. Used by lot tracking, display (Python-compat post-booking per-unit form), and validation reads that want a per-unit value.

total: Decimal

Original total as written. Used by residual calculation to avoid the division-then-multiplication precision loss that would otherwise leak into balance checks.

Implementations

impl BookedCost

pub fn new(per_unit: Decimal, total: Decimal, units: Decimal) -> Self

Construct from booking with a precision invariant check.

In debug builds, asserts that per_unit * |units| ≈ total to the limits of rust_decimal precision (tolerance: max(1e-20, |total| * 1e-24), derived from the booker’s total / |units| divisor truncating at 28 significant digits; see the private check_invariant helper for the exact computation). Callers are the booker (which derives per_unit = total / |units|) and the plugin / FFI ingress bridges (which must validate consistency before constructing).

Panics

In debug builds: if the invariant fails. Release builds skip the check (but trust-boundary callers should use Self::try_new for runtime validation in release too).

pub fn try_new( per_unit: Decimal, total: Decimal, units: Decimal, ) -> Result<Self, BookedCostInvariantError>

Try to construct, returning a typed error if the consistency invariant fails. Use this at trust boundaries (FFI input, plugin egress) where the caller may have supplied inconsistent values and you want to reject rather than panic in debug or accept silently in release.

Errors

Returns BookedCostInvariantError when:

• units == 0 (the post-booking shape is structurally undefined for zero units; callers should send PerUnit or Total instead).
• per_unit * |units| differs from total by more than max(1e-20, |total| * 1e-24).

Trait Implementations

impl Archive for BookedCost

where AsDecimal: ArchiveWith<Decimal>,

type Archived = ArchivedBookedCost

The archived representation of this type.

type Resolver = BookedCostResolver

The resolver for this type. It must contain all the additional information from serializing needed to make the archived type from the normal type.

fn resolve(&self, resolver: Self::Resolver, out: Place<Self::Archived>)

Creates the archived version of this value at the given position and writes it to the given output.

const COPY_OPTIMIZATION: CopyOptimization<Self> = _

An optimization flag that allows the bytes of this type to be copied directly to a writer instead of calling serialize.

impl Clone for BookedCost

fn clone(&self) -> BookedCost

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for BookedCost

impl Debug for BookedCost

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for BookedCost

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<__D: Fallible + ?Sized> Deserialize<BookedCost, __D> for Archived<BookedCost>

where AsDecimal: ArchiveWith<Decimal> + DeserializeWith<<AsDecimal as ArchiveWith<Decimal>>::Archived, Decimal, __D>,

fn deserialize( &self, deserializer: &mut __D, ) -> Result<BookedCost, <__D as Fallible>::Error>

Deserializes using the given deserializer

impl Eq for BookedCost

impl Hash for BookedCost

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for BookedCost

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for BookedCost

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<__S: Fallible + ?Sized> Serialize<__S> for BookedCost

where AsDecimal: SerializeWith<Decimal, __S>,

fn serialize( &self, serializer: &mut __S, ) -> Result<<Self as Archive>::Resolver, <__S as Fallible>::Error>

Writes the dependencies for the object and returns a resolver that can create the archived type.

impl ShiftSpans for BookedCost

fn shift_spans<F: Fn(&mut Span)>(&mut self, shift: &F)

Apply shift to every Span reachable in self.

impl StructuralPartialEq for BookedCost