Enum TierBudgetSpec 

#[non_exhaustive]
pub enum TierBudgetSpec {
    Auto,
    Percent(u8),
    Bytes(u64),
}

One tiering budget, as configured (not yet resolved to bytes).

use kevy_config::TierBudgetSpec;

let spec = TierBudgetSpec::parse("50%")?;
assert_eq!(spec.resolve_with(Some(8_000_000_000)), Some(4_000_000_000));
assert_eq!(spec.resolve_with(None), None, "no bound detected: no guess");

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

Auto

"auto" — 0.70 × the detected memory bound, re-probed on the shard tick.

use kevy_config::TierBudgetSpec;

assert_eq!(TierBudgetSpec::parse("auto")?, TierBudgetSpec::Auto);
assert_eq!(TierBudgetSpec::Auto.resolve_with(Some(1000)), Some(700));

Percent(u8)

"70%" — that percent of the detected bound (1..=100).

use kevy_config::TierBudgetSpec;

assert_eq!(TierBudgetSpec::parse("25%")?, TierBudgetSpec::Percent(25));
assert_eq!(TierBudgetSpec::Percent(25).resolve_with(Some(4000)), Some(1000));

Bytes(u64)

"4gb" / plain integer — absolute bytes.

use kevy_config::TierBudgetSpec;

assert_eq!(TierBudgetSpec::parse("4gb")?, TierBudgetSpec::Bytes(4 << 30));
assert_eq!(TierBudgetSpec::Bytes(4096).resolve_with(None), Some(4096)); // needs no probe

Implementations

impl TierBudgetSpec

pub fn parse(s: &str) -> Result<TierBudgetSpec, ValueError>

Parse the wire/TOML/env text form. Accepts auto, N% (1..=100), and any parse_size literal (4gb, 512mb, bare bytes). Garbage errors by name.

use kevy_config::TierBudgetSpec;
assert_eq!(TierBudgetSpec::parse("70%"), Ok(TierBudgetSpec::Percent(70)));
assert!(TierBudgetSpec::parse("0%").is_err());

pub fn resolve_with(self, detected_bound: Option<u64>) -> Option<u64>

Resolve to bytes given the probed memory bound. Bytes ignores the probe; Auto/Percent return None when no bound was detected (the caller refuses by name — never a silent guess).

use kevy_config::TierBudgetSpec;

let bound = Some(10 << 30); // e.g. a 10 GiB cgroup limit
assert_eq!(TierBudgetSpec::Auto.resolve_with(bound), Some((10 << 30) / 100 * 70));
assert_eq!(TierBudgetSpec::Percent(70).resolve_with(None), None);
assert_eq!(TierBudgetSpec::Bytes(1 << 20).resolve_with(bound), Some(1 << 20));

pub fn to_config_string(self) -> String

The canonical config-file text form (auto / 70% / bytes).

use kevy_config::TierBudgetSpec;
assert_eq!(TierBudgetSpec::Percent(70).to_config_string(), "70%");
assert_eq!(TierBudgetSpec::Bytes(4096).to_config_string(), "4096");

Trait Implementations

impl Clone for TierBudgetSpec

fn clone(&self) -> TierBudgetSpec

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for TierBudgetSpec

impl Debug for TierBudgetSpec

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

Formats the value using the given formatter.

impl Eq for TierBudgetSpec

impl Hash for TierBudgetSpec

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 TierBudgetSpec

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for TierBudgetSpec