Trait Ticks

pub trait Ticks:
    Clone
    + Copy
    + From<u32>
    + Debug
    + Ord
    + PartialOrd
    + Eq {
    // Required methods
    fn width() -> u32;
    fn into_usize(self) -> usize;
    fn into_u32(self) -> u32;
    fn wrapping_add(self, other: Self) -> Self;
    fn wrapping_sub(self, other: Self) -> Self;
    fn within_range(self, start: Self, end: Self) -> bool;
    fn max_value() -> Self;
    fn half_max_value() -> Self;
    fn from_or_max(val: u64) -> Self;
    fn saturating_scale(self, numerator: u32, denominator: u32) -> u32;

    // Provided methods
    fn usize_padding() -> u32 { ... }
    fn into_usize_left_justified(self) -> usize { ... }
    fn usize_left_justified_scale_freq<F: Frequency>() -> u32 { ... }
    fn u32_padding() -> u32 { ... }
    fn into_u32_left_justified(self) -> u32 { ... }
    fn u32_left_justified_scale_freq<F: Frequency>() -> u32 { ... }
}

An integer type defining the width of a time value, which allows clients to know when wraparound will occur.

Required Methods

fn width() -> u32

Width of the actual underlying timer in bits.

The maximum value that will be attained by this timer should be (2 ** width) - 1. In other words, the timer will wrap at exactly width bits, and then continue counting at 0.

The return value is a u32, in accordance with the bit widths specified using the BITS associated const on Rust integer types.

fn into_usize(self) -> usize

Converts the type into a usize, stripping the higher bits it if it is larger than usize and filling the higher bits with 0 if it is smaller than usize.

fn into_u32(self) -> u32

Converts the type into a u32, stripping the higher bits it if it is larger than u32 and filling the higher bits with 0 if it is smaller than u32. Included as a simple helper since Tock uses u32 pervasively and most platforms are 32 bits.

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

Add two values, wrapping around on overflow using standard unsigned arithmetic.

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

Subtract two values, wrapping around on underflow using standard unsigned arithmetic.

fn within_range(self, start: Self, end: Self) -> bool

Returns whether the value is in the range of [start, end) using unsigned arithmetic and considering wraparound. It returns trueif, incrementing fromstart, the value will be reached before end. Put another way, it returns (self - start) < (end - start)` in unsigned arithmetic.

fn max_value() -> Self

Returns the maximum value of this type, which should be (2^width)-1.

fn half_max_value() -> Self

Returns the half the maximum value of this type, which should be (2^width-1).

fn from_or_max(val: u64) -> Self

Converts the specified val into this type if it fits otherwise the max_value() is returned

fn saturating_scale(self, numerator: u32, denominator: u32) -> u32

Scales the ticks by the specified numerator and denominator. If the resulting value would be greater than u32,u32::MAX is returned instead

Provided Methods

fn usize_padding() -> u32

The amount of bits required to left-justify this ticks value range (filling the lower bits with 0) for it wrap at (2 ** usize::BITS) - 1 bits. For timers with a width larger than usize, this value will be 0 (i.e., they can simply be truncated to usize::BITS bits).

fn into_usize_left_justified(self) -> usize

Converts the type into a usize, left-justified and right-padded with 0 such that it is guaranteed to wrap at (2 ** usize::BITS) - 1. If it is larger than usize::BITS bits, any higher bits are stripped.

The resulting tick rate will possibly be higher (multiplied by 2 ** usize_padding()). Use usize_left_justified_scale_freq to convert the underlying timer’s frequency into the padded ticks frequency in Hertz.

fn usize_left_justified_scale_freq<F: Frequency>() -> u32

Convert the generic Frequency argument into a frequency (Hertz) describing a left-justified ticks value as returned by Ticks::into_usize_left_justified.

fn u32_padding() -> u32

The amount of bits required to left-justify this ticks value range (filling the lower bits with 0) for it wrap at (2 ** 32) - 1 bits. For timers with a width larger than 32, this value will be 0 (i.e., they can simply be truncated to 32-bits).

The return value is a u32, in accordance with the bit widths specified using the BITS associated const on Rust integer types.

fn into_u32_left_justified(self) -> u32

Converts the type into a u32, left-justified and right-padded with 0 such that it is guaranteed to wrap at (2 ** 32) - 1. If it is larger than 32-bits, any higher bits are stripped.

The resulting tick rate will possibly be higher (multiplied by 2 ** u32_padding()). Use u32_left_justified_scale_freq to convert the underlying timer’s frequency into the padded ticks frequency in Hertz.

fn u32_left_justified_scale_freq<F: Frequency>() -> u32

Convert the generic Frequency argument into a frequency (Hertz) describing a left-justified ticks value as returned by Ticks::into_u32_left_justified.

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementors

impl Ticks for Ticks16

impl Ticks for Ticks24

impl Ticks for Ticks32

impl Ticks for Ticks64