Struct Tick 

#[repr(transparent)]
pub struct Tick(pub u64);

An instant or duration in cycles of the PC’s 315/22 MHz crystal.

One cycle is exactly 22/315 microseconds. PIT input cycles span 12 ticks; an OPL native sample spans 288 ticks. Integer conversions round down to whole ticks. For repeated charges, use TickAccumulator to retain the fractional part.

Arithmetic panics on overflow or subtraction below zero in all build profiles.

Tuple Fields

0: u64

Implementations

impl Tick

pub const ZERO: Tick

Power-on time, or a zero duration.

pub const MAX: Tick

Largest representable timestamp or duration.

pub const HZ_NUMERATOR: u64 = 315_000_000

Numerator of the crystal frequency in hertz.

pub const HZ_DENOMINATOR: u64 = 22

Denominator of the crystal frequency in hertz.

pub const fn from_micros(micros: u64) -> Tick

Convert integer microseconds, rounding down.

Panics

Panics if the result exceeds Tick::MAX.

pub const fn from_nanos(nanos: u64) -> Tick

Convert integer nanoseconds, rounding down.

pub const fn from_duration(duration: Duration) -> Tick

Convert a duration, rounding down.

Panics

Panics if the result exceeds Tick::MAX.

pub const fn checked_from_duration(duration: Duration) -> Option<Tick>

Convert a duration, returning None on overflow.

pub fn from_secs_f64(seconds: f64) -> Tick

Convert approximate floating-point seconds, rounding to the nearest tick.

Rounding makes Tick::from_secs_f64(t.as_secs_f64()) == t despite float error. Prefer Self::from_duration when exact integer conversion matters.

Panics

Panics for negative, non-finite or out-of-range input.

pub const fn as_duration(self) -> Duration

Convert to a duration, rounding down to whole nanoseconds.

pub fn as_secs_f64(self) -> f64

Approximate seconds, for display or compatibility with older clocks.

pub fn as_nanos_f64(self) -> f64

Approximate nanoseconds, for compatibility with older device interfaces.

pub const fn checked_add(self, rhs: Tick) -> Option<Tick>

Add a duration, returning None on overflow.

pub const fn checked_sub(self, rhs: Tick) -> Option<Tick>

Subtract an instant or duration, returning None if rhs is greater.

Trait Implementations

impl Add for Tick

type Output = Tick

The resulting type after applying the + operator.

fn add(self, rhs: Tick) -> Tick

Performs the + operation.

impl AddAssign for Tick

fn add_assign(&mut self, rhs: Tick)

Performs the += operation.

impl Clone for Tick

fn clone(&self) -> Tick

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for Tick

impl Debug for Tick

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

Formats the value using the given formatter.

impl Default for Tick

fn default() -> Tick

Returns the “default value” for a type.

impl Eq for Tick

impl Hash for Tick

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 Ord for Tick

fn cmp(&self, other: &Tick) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

fn clamp_to<R>(self, range: R) -> Self

where Self: Sized, R: ClampBounds<Self>,

🔬This is a nightly-only experimental API. (clamp_to)

Restrict a value to a certain range.

impl PartialEq for Tick

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

Equality operator ==.

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

Inequality operator !=.

impl PartialOrd for Tick

fn partial_cmp(&self, other: &Tick) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl StructuralPartialEq for Tick

impl Sub for Tick

type Output = Tick

The resulting type after applying the - operator.

fn sub(self, rhs: Tick) -> Tick

Performs the - operation.

impl SubAssign for Tick

fn sub_assign(&mut self, rhs: Tick)

Performs the -= operation.