Type Alias UtcClockTransform

pub type UtcClockTransform = ClockTransformation<BootTimeline, UtcTimeline>;

A transformation for the UTC clock.

Aliased Type

struct UtcClockTransform {
    pub reference_offset: Instant<BootTimeline>,
    pub synthetic_offset: Instant<UtcTimeline>,
    pub rate: zx_clock_rate_t,
}

Fields

reference_offset: Instant<BootTimeline>

The offset on the reference timeline, measured in reference clock ticks.

synthetic_offset: Instant<UtcTimeline>

The offset on the clock timeline, measured in clock ticks (typically normalized to nanoseconds).

rate: zx_clock_rate_t

The ratio of the reference to clock rate.

Implementations

impl<Reference, Output> ClockTransformation<Reference, Output>

where Reference: Timeline + Copy, Output: Timeline + Copy,

Clock transformations can be applied to convert a time from a reference time to a synthetic time. The inverse transformation can be applied to convert a synthetic time back to the reference time.

pub fn apply(&self, time: Instant<Reference>) -> Instant<Output>

pub fn apply_inverse(&self, time: Instant<Output>) -> Instant<Reference>

Trait Implementations

impl<Reference, Output> Clone for ClockTransformation<Reference, Output>

where Reference: Clone, Output: Clone,

fn clone(&self) -> ClockTransformation<Reference, Output>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<Reference, Output> Debug for ClockTransformation<Reference, Output>

where Reference: Debug, Output: Debug,

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

Formats the value using the given formatter.

impl<Reference, Output> From<zx_clock_transformation_t> for ClockTransformation<Reference, Output>

where Reference: Timeline, Output: Timeline,

fn from(ct: zx_clock_transformation_t) -> ClockTransformation<Reference, Output>

Converts to this type from the input type.

impl<Reference, Output> PartialEq for ClockTransformation<Reference, Output>

where Reference: PartialEq, Output: PartialEq,

fn eq(&self, other: &ClockTransformation<Reference, Output>) -> 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<Reference, Output> Eq for ClockTransformation<Reference, Output>

where Reference: Eq, Output: Eq,

impl<Reference, Output> StructuralPartialEq for ClockTransformation<Reference, Output>