Struct ClockTransformation

pub struct ClockTransformation<Reference = MonotonicTimeline, Output = SyntheticTimeline> {
    pub reference_offset: Instant<Reference>,
    pub synthetic_offset: Instant<Output>,
    pub rate: zx_clock_rate_t,
}

A one-dimensional affine transformation that maps points from the reference timeline to the clock timeline. See clock transformations.

Fields

reference_offset: Instant<Reference>

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

synthetic_offset: Instant<Output>

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: Timeline + Copy, Output: Timeline + Copy> ClockTransformation<Reference, Output>

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>

Apply the transformation to convert a time from the reference timeline to the output timeline.

Panics

If the reference clock rate is zero, this function will panic.

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

Apply the transformation to convert a time from the output timeline to the reference timeline.

Panics

If the output clock rate is zero, this function will panic.

Trait Implementations

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

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

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

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

Formats the value using the given formatter.

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

fn from(ct: zx_clock_transformation_t) -> Self

Converts to this type from the input type.

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

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: Eq, Output: Eq> Eq for ClockTransformation<Reference, Output>

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