Struct Timestamp 

pub struct Timestamp(pub byztime_stamp);

A timestamp with nanosecond resolution

Tuple Fields

0: byztime_stamp

Implementations

impl Timestamp

pub fn new(seconds: i64, nanoseconds: i64) -> Timestamp

Build a timestamp from a given count of seconds and nanoseconds

pub fn seconds(self) -> i64

Return the seconds portion of the timestamp

pub fn nanoseconds(self) -> i64

Return the nanoseconds portion of the timestamp

pub fn normalize(self) -> Timestamp

Normalizes the timestamp such that 0 ≤ nanoseconds < 1_000_000_000.

pub fn overflowing_normalize(self) -> (Timestamp, bool)

Normalizes the timestamp such that 0 ≤ nanoseconds < 1_000_000_000.

Returns a tuple of the normalized timestamp along with a boolean indicating whether an arithmetic overflow occurred. If an overflow did occur then the 2s-complement wrapped value is returned.

pub fn wrapping_normalize(self) -> Timestamp

Normalizes the timestamp such that 0 ≤ nanoseconds < 1_000_000_000. If an overflow occurs, returns the 2s-complement wrapped value.

pub fn saturating_normalize(self) -> Timestamp

Normalizes the timestamp such that 0 ≤ nanoseconds < 1_000_000_000.

pub fn checked_normalize(self) -> Option<Timestamp>

Normalizes the timestamp such that 0 ≤ nanoseconds < 1_000_000_000, returning None if overflow occurred.

pub fn local_time() -> Result<Timestamp>

Return a timestamp representing the current local time

“Local” here is in the Byztime sense of local to this machine, not the civil sense of local to a timezone.

pub fn real_time() -> Result<Timestamp>

Return a timestamp representing the current real time, i.e., POSIX time

pub fn overflowing_add(self, rhs: Timestamp) -> (Timestamp, bool)

Calculates self + rhs.

Returns a tuple of the addition along with a boolean indicating whether an arithmetic overflow occurred. If an overflow occurred then the wrapped value is returned.

pub fn overflowing_sub(self, rhs: Timestamp) -> (Timestamp, bool)

Calculates self - rhs.

Returns a tuple of the subtraction along with a boolean indicating whether an arithmetic overflow occurred. If an overflow occurred then the wrapped value is returned.

pub fn checked_add(self, rhs: Timestamp) -> Option<Timestamp>

Checked addition of timestamps. Computes self + rhs, returning None if overflow occurred.

pub fn checked_sub(self, rhs: Timestamp) -> Option<Timestamp>

Checked subtractions of timestamps. Computes self - rhs, returning None if overflow occurred.

pub fn wrapping_add(self, rhs: Timestamp) -> Timestamp

Wrapping addition of timestamps. Computess self + rhs, wrapping around at the boundary of the type.

pub fn wrapping_sub(self, rhs: Timestamp) -> Timestamp

Wrapping subtraction of timestamps. Computess self - rhs, wrapping around at the boundary of the type.

pub fn saturating_add(self, rhs: Timestamp) -> Timestamp

Saturating addition of timestamps. Computes self + rhs, saturating at numeric bounds instead of overflowing.

pub fn saturating_sub(self, rhs: Timestamp) -> Timestamp

Saturating subtraction of timestamps. Computes self - rhs, saturating at numeric bounds instead of overflowing.

pub fn overflowing_scale(self, ppb: i64) -> (Timestamp, bool)

Multiplies the timestamp by ppb parts per billion.

Returns a tuple of the multiplication along with a boolean indicating whether an arithmetic overflow occurred. If an overflow occurred then the wrapped value is returned.

pub fn scale(self, ppb: i64) -> Timestamp

Multiplies the timestamp by ppb parts per billion.

pub fn checked_scale(self, ppb: i64) -> Option<Timestamp>

Multiplies the timestamp by ppb parts per billion, returning None if overflow occurred.

pub fn wrapping_scale(self, ppb: i64) -> Timestamp

Multiplies the timestamp by ppb parts per billion, wrapping around at the limits of the type if overflow occurs.

pub fn saturating_scale(self, ppb: i64) -> Timestamp

Multiplies the timestamp by ppb parts per billion, saturating at numeric bounds rather than overflowing.

pub fn halve(self) -> Timestamp

Divides the timestamp by two.

pub fn min_value() -> Timestamp

Returns the smallest (most negative) value representable by this type.

pub fn max_value() -> Timestamp

Returns the largest value representable by this type.

pub fn max_error() -> Timestamp

Returns half of the largest value representable by this type. This value is used as an error term when the clock is unsynchronized.

Trait Implementations

impl Add for Timestamp

type Output = Timestamp

The resulting type after applying the + operator.

fn add(self, other: Timestamp) -> Timestamp

Performs the + operation.

impl AddAssign for Timestamp

fn add_assign(&mut self, other: Timestamp)

Performs the += operation.

impl Clone for Timestamp

fn clone(&self) -> Timestamp

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Timestamp

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

Formats the value using the given formatter.

impl Default for Timestamp

fn default() -> Timestamp

Returns the “default value” for a type.

impl Display for Timestamp

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

Formats the value using the given formatter.

impl Ord for Timestamp

fn cmp(&self, other: &Timestamp) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl PartialEq for Timestamp

fn eq(&self, other: &Timestamp) -> 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 PartialOrd for Timestamp

fn partial_cmp(&self, other: &Timestamp) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl Sub for Timestamp

type Output = Timestamp

The resulting type after applying the - operator.

fn sub(self, other: Timestamp) -> Timestamp

Performs the - operation.

impl SubAssign for Timestamp

fn sub_assign(&mut self, other: Timestamp)

Performs the -= operation.

impl Copy for Timestamp

impl Eq for Timestamp