Struct sttp::Ticks

pub struct Ticks { /* private fields */ }

Represents a 64-bit integer used to designate time in STTP. The value represents the number of 100-nanosecond intervals that have elapsed since 12:00:00 midnight, January 1, 0001 UTC, Gregorian calendar.

A single tick represents one hundred nanoseconds, or one ten-millionth of a second. There are 10,000 ticks in a millisecond and 10 million ticks in a second. Only bits 01 to 62 (0x3FFFFFFFFFFFFFFF) are used to represent the timestamp value. Bit 64 (0x8000000000000000) is used to denote leap second, i.e., second 60, where actual second value would remain at 59. Bit 63 (0x4000000000000000) is used to denote leap second direction, 0 for add, 1 for delete.

Implementations

impl Ticks

pub const PER_SECOND: u64 = 10_000_000u64

Number of Ticks that occur in a second.

pub const PER_MILLISECOND: u64 = 10_000_000u64

Number of Ticks that occur in a millisecond.

pub const PER_MICROSECOND: u64 = 10u64

Number of Ticks that occur in a microsecond.

pub const PER_MINUTE: u64 = 600_000_000u64

Number of Ticks that occur in a minute.

pub const PER_HOUR: u64 = 36_000_000_000u64

Number of Ticks that occur in an hour.

pub const PER_DAY: u64 = 864_000_000_000u64

Number of Ticks that occur in a day.

pub const LEAP_SECOND_FLAG: u64 = 9_223_372_036_854_775_808u64

Flag (64th bit) that marks a Ticks value as a leap second, i.e., second 60 (one beyond normal second 59).

pub const LEAP_SECOND_DIRECTION: u64 = 4_611_686_018_427_387_904u64

Flag (63rd bit) that indicates if leap second is positive or negative; 0 for add, 1 for delete.

pub const VALUE_MASK: u64 = 4_611_686_018_427_387_903u64

All bits (bits 1 to 62) that make up the value portion of a Ticks that represent time.

pub const UNIX_BASE_OFFSET: u64 = 621_355_968_000_000_000u64

Ticks representation of the Unix epoch timestamp starting at January 1, 1970.

pub fn new(val: u64) -> Self

Creates a Ticks value.

pub fn timestamp_value(&self) -> u64

Gets the timestamp portion of the Ticks value, i.e., the 62-bit time value excluding any leap second flags.

pub fn from_datetime<Tz: TimeZone>(dt: DateTime<Tz>) -> Selfwhere
    DateTime<Tz>: From<SystemTime>,

Converts a standard Rust DateTime value to a Ticks value.

pub fn from_duration(duration: Duration) -> Self

Converts a standard Rust Duration value to a Ticks value.

pub fn to_datetime(&self) -> DateTime<Utc>

Converts a Ticks value to standard Rust DateTime value.

pub fn is_leap_second(&self) -> bool

Determines if the deserialized Ticks value represents a leap second, i.e., second 60.

pub fn set_leap_second(&self) -> Self

Returns a copy of this Ticks value flagged to represent a leap second, i.e., second 60, before wire serialization.

pub fn apply_leap_second(&mut self)

Updates this Ticks value to represent a leap second, i.e., second 60, before wire serialization.

pub fn is_negative_leap_second(&self) -> bool

Determines if the deserialized Ticks value represents a negative leap second, i.e., checks flag on second 58 to see if second 59 will be missing.

pub fn set_negative_leap_second(&self) -> Self

Returns a copy of this Ticks value flagged to represent a negative leap second, i.e., sets flag on second 58 to mark that second 59 will be missing, before wire serialization.

pub fn apply_negative_leap_second(&mut self)

Updates this Ticks value to represent a negative leap second, i.e., sets flag on second 58 to mark that second 59 will be missing, before wire serialization.

pub fn now() -> Self

Gets the current local time as a Ticks value.

pub fn utc_now() -> Self

Gets the current time in UTC as a Ticks value.

pub fn to_string(&self) -> String

Standard timestamp representation for a Ticks value, e.g., 2006-01-02 15:04:05.999999999.

pub fn to_short_string(&self) -> String

Shows just the timestamp portion of a Ticks value with milliseconds, e.g., 15:04:05.999.

Trait Implementations

impl Add<Ticks> for Ticks

type Output = Ticks

The resulting type after applying the + operator.

fn add(self, rhs: Ticks) -> Self

Performs the + operation.

impl Clone for Ticks

fn clone(&self) -> Ticks

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Ticks

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

Formats the value using the given formatter.

impl Default for Ticks

fn default() -> Ticks

Returns the “default value” for a type.

impl Display for Ticks

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

Formats the value using the given formatter.

impl Div<Ticks> for Ticks

type Output = Ticks

The resulting type after applying the / operator.

fn div(self, rhs: Ticks) -> Self

Performs the / operation.

impl Hash for Ticks

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 Mul<Ticks> for Ticks

type Output = Ticks

The resulting type after applying the * operator.

fn mul(self, rhs: Ticks) -> Self

Performs the * operation.

impl Ord for Ticks

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

This method returns an Ordering between self and other.

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

Compares and returns the maximum of two values.

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

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Selfwhere
    Self: Sized + PartialOrd<Self>,

Restrict a value to a certain interval.

impl PartialEq<Ticks> for Ticks

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

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

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

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

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

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

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

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

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

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

type Output = Ticks

The resulting type after applying the - operator.

fn sub(self, rhs: Ticks) -> Self

Performs the - operation.

impl Copy for Ticks

impl Eq for Ticks

impl StructuralEq for Ticks

impl StructuralPartialEq for Ticks