Enum Total 

pub enum Total {
    Exact(EstimatedUsd),
    AtLeast {
        floor: EstimatedUsd,
        unpriced: Vec<UnpricedLine>,
    },
}

A report’s total, which is a lower bound whenever anything is unpriced (COST-4).

Two variants rather than a struct with a flag, and that is the upgrade over the Python’s Total(priced, unpriced=()): there a consumer could read .priced and never look at .is_lower_bound, so the honesty rule depended on the caller checking. Here the floor is inside Total::AtLeast, beside the reasons, so reaching it means seeing them. A plain sum cannot express “everything we could price, plus a build AWS will not tell us the price of”, and the natural way to force it to — dropping the unpriced line — is exactly the lie this module exists not to tell.

Variants

Exact(EstimatedUsd)

Every line item was priced, so this is the whole estimate.

AtLeast

At least this much, plus line items with no published rate.

Fields

floor: EstimatedUsd

The sum of the priced lines. Not the total — the total is unknowable.

unpriced: Vec<UnpricedLine>

The lines that could not be priced, in report order.

Non-empty by construction: Total::of answers Total::Exact when there is nothing to name, so an AtLeast with an empty list — a lower bound that will not say what it is missing — is not a value this type holds.

Implementations

impl Total

pub fn of<'a>( amounts: impl IntoIterator<Item = (CostPhase, &'a Amount)>, ) -> Total

The total over a report’s amounts, each labelled with the phase it came from.

The one place a total is computed, so COST-4 holds for every consumer rather than for the ones that remembered. An unpriced amount routes the whole answer to Total::AtLeast; it is never skipped and never summed as zero.

Takes (phase, amount) rather than a bare amount so the phase cannot go missing on the way in: the rendered total names phases, and a Total built without them could only fall back to printing reasons.

pub fn floor(&self) -> EstimatedUsd

Everything that could be priced.

Named floor rather than total on purpose: for Total::AtLeast it is a lower bound, and a consumer reading a field called total would have no reason to check which variant it came from.

pub fn is_lower_bound(&self) -> bool

True when line items with no published rate are missing from the floor.

pub fn unpriced_lines(&self) -> &[UnpricedLine]

The lines that could not be priced. Empty for Total::Exact.

pub fn unpriced_reasons(&self) -> Vec<String>

The reasons the unpriced lines could not be priced, in report order. Empty for Total::Exact.

Kept beside Total::unpriced_lines because the reason is what a consumer surfacing the why wants, while the rendered total names phases.

pub fn unpriced_phase_names(&self) -> Vec<&'static str>

The distinct phase names of the unpriced lines, sorted — what the rendered total names.

Sorted and deduplicated to match cost.py:342’s ", ".join(sorted({item.phase.value for item in self.unpriced})): two unpriced lines in one phase name it once, and the order does not depend on report order.

Trait Implementations

impl Clone for Total

fn clone(&self) -> Total

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Total

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

Formats the value using the given formatter.

impl Display for Total

“at least” is the whole point, so it leads.

The parenthetical names phases, not reasons, which is cost.py:343 verbatim. A reason is a sentence explaining what AWS does not publish, and joining several of them turns a one-line total into a paragraph the two clients cannot both print.

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

Formats the value using the given formatter.

impl Eq for Total

impl PartialEq for Total

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for Total