Enum TimeScale 

pub enum TimeScale {
    Years,
    Days,
    Hours,
    Minutes,
    Seconds,
    Milliseconds,
    Microseconds,
    Nanoseconds,
    Ratio(Ratio<NonZeroU32, NonZeroU32>),
}

🕘 Describes the conceptual scale at which time is expressed or interpreted.

---

^{📍 phys/time}

---

TimeScale is lightweight, descriptive metadata. It can be used to label time sources, parameters, or policies without implying exact duration, normalization, or convertibility between scales.

Calendar-based variants (such as years or days) are symbolic and may depend on external conventions. The Ratio variant allows expressing custom scales relative to seconds.

Variants

Years

Days

Hours

Minutes

Seconds

Default time scale.

Milliseconds

Microseconds

Nanoseconds

Ratio(Ratio<NonZeroU32, NonZeroU32>)

A custom, exact time scale expressed as a rational multiple of seconds.

Implementations

impl TimeScale

Aliases

pub const Mins: Self = Self::Minutes

Alias for Minutes.

pub const Secs: Self = Self::Seconds

Alias for Seconds.

pub const Millis: Self = Self::Milliseconds

Alias for Milliseconds.

pub const Micros: Self = Self::Microseconds

Alias for Microseconds.

pub const Nanos: Self = Self::Nanoseconds

Alias for Nanoseconds.

impl TimeScale

pub const fn is_calendar(self) -> bool

Returns true if this scale is calendar-based.

pub const fn is_fixed(self) -> bool

Returns true if this scale is not calendar-based.

pub const fn is_subsecond(self) -> bool

Returns true if this scale is sub-second.

pub const fn is_second_based(self) -> bool

Returns true if this scale is second-based or finer.

pub const fn name(self) -> &'static str

Returns a short, lowercase name for this time scale.

pub const fn convert(self, value: u64, target: TimeScale) -> Option<u64>

Converts a numeric value from this scale into target, if both scales have a fixed, exact ratio to seconds.

Returns None if either scale is calendar-based.

pub fn convert_simulated(self, value: u64, target: TimeScale) -> u64

Converts a numeric value from this scale into target using fixed, simulation-friendly assumptions.

Calendar-based scales are treated as fixed-duration:

• Days = 24 hours
• Years = 365 days

This method never fails and is intended for testing, simulation, and synthetic time sources.

impl TimeScale

pub const fn new_ratio(num: u32, den: u32) -> Option<Self>

Creates a ratio-based time scale relative to seconds.

Returns None if either component is zero.

pub const fn some_ratio(self) -> Option<Ratio<NonZeroU32, NonZeroU32>>

Returns the underlying ratio if this scale is already expressed as one.

pub const fn to_ratio(self) -> Option<Ratio<NonZeroU32, NonZeroU32>>

Returns the exact ratio of this scale relative to seconds, if fixed-duration.

The returned ratio expresses: 1 unit of this scale = num / den seconds

Calendar-based scales (Days, Years) return None.

pub const fn to_ratio_simulated(self) -> Ratio<NonZeroU32, NonZeroU32>

Returns a simulation-friendly ratio of this scale relative to seconds.

The returned ratio expresses: 1 unit of this scale = num / den seconds

Unlike to_ratio, this method never fails. Calendar-based scales are mapped to fixed-duration approximations:

• Days are treated as 24-hour days.
• Years are treated as 365-day years.

This method is intended for testing, simulation, and synthetic time sources where deterministic behavior is preferred over civil-time accuracy.

Trait Implementations

impl Clone for TimeScale

fn clone(&self) -> TimeScale

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for TimeScale

impl Debug for TimeScale

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

Formats the value using the given formatter.

impl Default for TimeScale

fn default() -> TimeScale

Returns the “default value” for a type.

impl Eq for TimeScale

impl Hash for TimeScale

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 TimeScale

fn eq(&self, other: &TimeScale) -> 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 StructuralPartialEq for TimeScale