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, 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>