Enum CostPhase 

pub enum CostPhase {
    ImageBuild,
    ImageStorage,
    Launch,
    Running,
    Suspended,
    Suspend,
    Resume,
}

The lifecycle a sandbox goes through, as the phases that cost money.

Variants

ImageBuild

ImageStorage

Launch

Running

Suspended

Suspend

Resume

Implementations

impl CostPhase

pub const ALL: [CostPhase; 7]

Every phase, in lifecycle order.

Public because a caller that has to judge a phase string needs the list to refuse with, and the two bindings each grew their own copy of this array before it existed here — a parallel table that would have gone stale the first time a phase was added. CostPhase::from_str is the reader; the round-trip test below is what stops a variant being added to the enum and forgotten here.

pub fn as_str(self) -> &'static str

The wire spelling, identical to the Python StrEnum member.

Trait Implementations

impl Clone for CostPhase

fn clone(&self) -> CostPhase

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for CostPhase

impl Debug for CostPhase

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

Formats the value using the given formatter.

impl Display for CostPhase

pad rather than write_str, because a phase is a column.

write_str ignores the formatter’s width entirely, so {:<14} on a phase silently produced a ragged table — every plain-text line’s dollar figure started at a different offset, and the fix looks like it is already there in the format string. fmt::Formatter::pad is the one spelling that honours width, precision, and alignment; write!(f, "{}", ...) here would recurse straight back into this impl and drop the width again.

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

Formats the value using the given formatter.

impl Eq for CostPhase

impl FromStr for CostPhase

fn from_str(phase: &str) -> Result<CostPhase, Error>

A phase from its wire spelling, refusing anything else with the whole list.

Here rather than in each caller because the callers are bindings: a Python or JS report.by_phase("running") has a bare string where Rust has a variant, so something has to judge it. Both bindings did, each with its own seven-element array — two parallel tables over a closed set, which is one table too many and two too many to keep in step with the enum. This is the single reader, and the list it offers on a refusal is CostPhase::ALL rather than a written-out sentence, so a phase added to the enum appears in the message without an edit.

Note the asymmetry with Region::from_str: a region’s refusal exists because an unlisted region is a plausible value this client has no evidence for, and there is an opt-in. A phase has no opt-in and needs none — the set is closed by the billing model, so an unrecognized spelling is a typo and nothing more.

type Err = Error

The associated error which can be returned from parsing.

impl Hash for CostPhase

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

where __H: Hasher,

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 CostPhase

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for CostPhase