Struct byztime::Timestamp

pub struct Timestamp(pub byztime_stamp);

A timestamp with nanosecond resolution

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<Timestamp> for Timestamp

type Output = Timestamp

The resulting type after applying the + operator.

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

Performs the + operation.

impl AddAssign<Timestamp> for Timestamp

fn add_assign(&mut self, other: Timestamp)

Performs the += operation.

impl Clone for Timestamp

fn clone(&self) -> Timestamp

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Copy for Timestamp

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 Eq for Timestamp

impl Ord for Timestamp

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

This method returns an Ordering between self and other.

#[must_use]pub fn max(self, other: Self) -> Self

Compares and returns the maximum of two values.

#[must_use]pub fn min(self, other: Self) -> Self

Compares and returns the minimum of two values.

#[must_use]pub fn clamp(self, min: Self, max: Self) -> Self

Restrict a value to a certain interval.

impl PartialEq<Timestamp> for Timestamp

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

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

#[must_use]pub fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl PartialOrd<Timestamp> for Timestamp

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

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

#[must_use]pub fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

#[must_use]pub fn le(&self, other: &Rhs) -> bool

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

#[must_use]pub fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

#[must_use]pub fn ge(&self, other: &Rhs) -> bool

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

impl Sub<Timestamp> for Timestamp

type Output = Timestamp

The resulting type after applying the - operator.

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

Performs the - operation.

impl SubAssign<Timestamp> for Timestamp

fn sub_assign(&mut self, other: Timestamp)

Performs the -= operation.