Enum omaha_client::time::PartialComplexTime

pub enum PartialComplexTime {
    Wall(SystemTime),
    Monotonic(Instant),
    Complex(ComplexTime),
}

PartialComplexTime provides a std::interator::EitherOrBoth-like type which is specifically for holding either one, or both, of the time types that make up a ComplexTime. It’s a type that holds a value for at least one of the timelines.

The important differentiation of this vs. a struct such as:

use std::time::SystemTime;
struct MaybeBoth {
  wall: Option<SystemTime>,
  monotonic: Option<SystemTime>
}

is that there is no valid (None, None) state for this type to be in, and so code that uses can be certain that some time is specified.

Like ComplexTime, PartialComplexTime implements all the standard math operations in std::ops that are implemented for both std::time::SystemTime and std::time:Instant. Like those implementations, they will panic on overflow.

Variants

Wall(SystemTime)

Just a wall time.

Monotonic(Instant)

Just a monotonic time.

Complex(ComplexTime)

Both a wall and a monotonic time.

Implementations

impl PartialComplexTime

pub fn checked_to_system_time(self) -> Option<SystemTime>

Return the SystemTime component, if one exists.

pub fn checked_to_instant(self) -> Option<Instant>

Return the Instant component, if one exists.

pub fn checked_to_micros_since_epoch(self) -> Option<i64>

Convert the SystemTime component of this PartialComplexTime into i64 microseconds from the UNIX Epoch. Provides coverage over +/- approx 30,000 years from 1970-01-01 UTC.

Returns None if it doesn’t have a wall time or on overflow (instead of panicking)

pub fn from_micros_since_epoch(micros: i64) -> Self

Return the PartialComplexTime::Wall that represents the same time as the specified microseconds from the UNIX Epoch (1970-01-01 UTC)

pub fn complete_with(&self, complex: ComplexTime) -> ComplexTime

Return a new ComplexTime that’s based on the time values of this PartialComplexTime, setting either unknown field from the passed-in ComplexTime.

pub fn destructure(&self) -> (Option<SystemTime>, Option<Instant>)

Destructure the PartialComplexTime into it’s two components, each as an Option.

Trait Implementations

impl Add<Duration> for PartialComplexTime

An Add implementation for PartialComplexTime that adds the duration to each of the time values it holds.

Panics

The Add implementations for both SystemTime and Instant, which this uses, will panic on overflow.

type Output = PartialComplexTime

The resulting type after applying the + operator.

fn add(self, dur: Duration) -> Self

Performs the + operation.

impl AddAssign<Duration> for PartialComplexTime

AddAssign implementation that relies on the above Add implementation.

fn add_assign(&mut self, other: Duration)

Performs the += operation.

impl Clone for PartialComplexTime

fn clone(&self) -> PartialComplexTime

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for PartialComplexTime

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

Formats the value using the given formatter.

impl Display for PartialComplexTime

PartialComplexTime implements Display to provide a human-readable, detailed, format for its values. It uses the ReadableSystemTime struct for its SystemTime component, and the Debug trait implementation of Instant, as that type’s internals are not accessible, and it only implements Debug.

Example

use std::time::{Duration, Instant, SystemTime};
use omaha_client::time::{ComplexTime, PartialComplexTime};

assert_eq!(
    format!("{}", PartialComplexTime::Complex(ComplexTime{
                      wall: SystemTime::UNIX_EPOCH + Duration::from_nanos(994610096026420000),
                      mono: Instant::now()
                  })),
    "2001-07-08 16:34:56.026 UTC (994610096.026420000) and Instant{ tv_sec: SEC, tv_nsec: NSEC }"
);

assert_eq!(
    format!("{}", PartialComplexTime::Wall(
                      SystemTime::UNIX_EPOCH + Duration::from_nanos(994610096026420000),
                  )),
    "2001-07-08 16:34:56.026 UTC (994610096.026420000) and Instant{ tv_sec: SEC, tv_nsec: NSEC }"
);

assert_eq!(
    format!("{}", PartialComplexTime::Monotonic(Instant::now())),
    "2001-07-08 16:34:56.026 UTC (994610096.026420000) and Instant{ tv_sec: SEC, tv_nsec: NSEC }"
);

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

Formats the value using the given formatter.

impl From<(SystemTime, Instant)> for PartialComplexTime

fn from(t: (SystemTime, Instant)) -> PartialComplexTime

Converts to this type from the input type.

impl From<ComplexTime> for PartialComplexTime

fn from(t: ComplexTime) -> Self

Converts to this type from the input type.

impl From<Instant> for PartialComplexTime

fn from(m: Instant) -> PartialComplexTime

Converts to this type from the input type.

impl From<SystemTime> for PartialComplexTime

fn from(w: SystemTime) -> PartialComplexTime

Converts to this type from the input type.

impl Hash for PartialComplexTime

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for PartialComplexTime

fn eq(&self, other: &PartialComplexTime) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Sub<Duration> for PartialComplexTime

A Sub implementation for PartialComplexTime that subtracts the duration to each of the time values it holds.

Panics

Panics when the result cannot be expressed in the underlying representation. Specifically, SystemTime, Instant, and ComplexTime may not be able to represent the resulting time.

type Output = PartialComplexTime

The resulting type after applying the - operator.

fn sub(self, dur: Duration) -> Self

Performs the - operation.

impl SubAssign<Duration> for PartialComplexTime

SubAssign implementation that relies on the above Add implementation.

fn sub_assign(&mut self, other: Duration)

Performs the -= operation.

impl Copy for PartialComplexTime

impl Eq for PartialComplexTime

impl StructuralPartialEq for PartialComplexTime