```
pub trait Ticks: Clone + Copy + From<u32> + Debug + Ord + PartialOrd + Eq {
```## Show 16 methods

// 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 { ... }
}

## Expand description

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

## Required Methods§

source#### fn width() -> u32

#### 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.

source#### fn into_usize(self) -> usize

#### 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`

.

source#### fn into_u32(self) -> u32

#### 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.

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

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

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

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

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

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

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

#### 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 `

true`if, incrementing from`

start`, the value will be reached before `

end`. Put another way, it returns `

(self - start) < (end - start)` in
unsigned arithmetic.

source#### fn half_max_value() -> Self

#### fn half_max_value() -> Self

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

source#### fn from_or_max(val: u64) -> Self

#### fn from_or_max(val: u64) -> Self

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

is returned

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

#### 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§

source#### fn usize_padding() -> u32

#### 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).

source#### fn into_usize_left_justified(self) -> usize

#### 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.

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

#### 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`

.

source#### fn u32_padding() -> u32

#### 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.

source#### fn into_u32_left_justified(self) -> u32

#### 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.

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

#### 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`

.

## Object Safety§

**not**object safe.