Struct hdk::prelude::Timestamp

pub struct Timestamp(pub i64, pub u32);

A UTC timestamp for use in Holochain’s headers. It is assumed to be untrustworthy: it may contain times offset from the UNIX epoch with the full +/- i64 range. Most of these times are not representable by a chrono::DateTime (which limits itself to a +/- i32 offset in days from Jan 1, 0AD and from 1970AD). Also, most differences between two Timestamps are not representable by either a chrono::Duration (which limits itself to +/- i64 milliseconds), nor by core::time::Duration (which limits itself to +’ve u64 seconds). Many constructions of these chrono and core::time types will panic!, so painful measures must be taken to avoid this outcome – it is not acceptable for our core Holochain algorithms to panic when accessing DHT Header information committed by other random Holochain nodes!

Timestamp implements Serialize and Display as rfc3339 time strings (if possible).

• Field 0: i64 - Seconds since UNIX epoch UTC (midnight 1970-01-01).
• Field 1: u32 - Nanoseconds in addition to above seconds, always in positive direction.

Supports +/- chrono::Duration directly. There is no Timestamp::now() method, since this is not supported by WASM; however, holochain_types provides a timestamp::now() method.

Create a new Timestamp instance from the supplied secs/nsecs. Note that we can easily create a Timestamp that cannot be converted to a valid DateTime (ie. by supplying 86,400-second days beyond range of +/- i32 offset from 0AD or 1970AD, nsecs beyond 1e9, etc.; see its code.)

Implementations

impl Timestamp

pub fn normalize(secs: i64, nanos: i64) -> Option<Timestamp>

Construct a normalized Timestamp from the given secs/nanos. Allows a full, signed range of seconds and/or nanoseconds; produces a Timestamp with a properly signed i64 seconds, and an always positive-offset u32 nanoseconds. Differs from typical new implementation in that it returns an Option.

use holochain_zome_types::prelude::*;
assert_eq!( Timestamp::normalize( 0, -1 ).unwrap(), Timestamp( -1, 999_999_999 ))

pub fn checked_difference_signed(&self, rhs: &Timestamp) -> Option<Duration>

Compute signed difference between two Timestamp, returning None if overflow occurred, or Some(chrono::Duration). Produces Duration for differences of up to +/- i64::MIN/MAX milliseconds (the full range of a signed chrono::Duration). Note that, surprisingly, there is almost no way to create a chrono::Duration that does not (directly or indirectly) have the possibility of panic! One of the few paths is Duration::milliseconds() and smaller (all larger use Duration::seconds, which may directly panic!), followed by a Duration::checked_add for the nanoseconds.

pub fn checked_add_signed(&self, rhs: &Duration) -> Option<Timestamp>

Add a signed chrono::Duration{ secs: i64, nanos: i32 } (-’ve nanos are invalid) to a Timestamp( i64, u32 ). May overflow. Unfortunately, there is no way in the provided API to actually obtain the raw { secs, nanos }, nor their component parts without overflow! The closest is to obtain the millis, subtract them out and obtain the residual nanoseconds…

use holochain_zome_types::prelude::*;

assert_eq!( Timestamp::normalize( 0, 1 ).unwrap()
                .checked_sub_signed(&chrono::Duration::nanoseconds(2)),
            Some(Timestamp( -1, 999_999_999 )));
//assert_eq!((Timestamp::normalize( 0, 1 ).unwrap()
//            - chrono::Duration::nanoseconds(2)),
//            Some(Timestamp( -1, 999_999_999 )));

pub fn checked_sub_signed(&self, rhs: &Duration) -> Option<Timestamp>

Subtracts a chrono::Duration from a Timestamp

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

Add unsigned core::time::Duration{ secs: u64, nanos: u32 } to a Timestamp. See: https://doc.rust-lang.org/src/core/time.rs.html#53-56

use holochain_zome_types::prelude::*;

assert_eq!( Timestamp::normalize( 0, -3 ).unwrap()
                .checked_add(&core::time::Duration::from_nanos(2)),
            Some(Timestamp( -1, 999_999_999 )));
assert_eq!( Timestamp::normalize( 0, 0 ).unwrap()
                .checked_add(&core::time::Duration::from_secs(2_u64.pow(32)-1)),
            Some(Timestamp( 2_i64.pow(32)-1, 0 )));
assert_eq!( Timestamp::normalize( 0, 0 ).unwrap()
                .checked_add(&core::time::Duration::from_secs(2_u64.pow(63)-1)),
            Some(Timestamp( (2_u64.pow(63)-1) as i64, 0 )));
assert_eq!( Timestamp::normalize( 0, 0 ).unwrap()
                .checked_add(&core::time::Duration::from_secs(2_u64.pow(63))),
            None);

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

Sub unsigned core::time::Duration{ secs: u64, nanos: u32 } from a Timestamp.

use holochain_zome_types::prelude::*;

assert_eq!( Timestamp::normalize( 0, 1 ).unwrap()
                .checked_sub(&core::time::Duration::from_nanos(2)),
            Some(Timestamp( -1, 999_999_999 )));
assert_eq!((Timestamp::normalize( 0, 1 ).unwrap()
            - core::time::Duration::from_nanos(2)),
            Ok(Timestamp( -1, 999_999_999 )));
assert_eq!( Timestamp::normalize( 550, 5_500_000_000 ).unwrap()
                .checked_sub(&core::time::Duration::from_nanos(2)),
            Some(Timestamp( 555, 499_999_998 )));

Trait Implementations

impl<'_, D> Add<D> for &'_ Timestamp where
    D: Into<Duration>, 

type Output = Result<Timestamp, TimestampError>

The resulting type after applying the + operator.

pub fn add(self, rhs: D) -> <&'_ Timestamp as Add<D>>::Output

Performs the + operation.

impl<D> Add<D> for Timestamp where
    D: Into<Duration>, 

Timestamp +/- Intocore::time::Duration: Anything that can be converted into a core::time::Duration can be used as an overflow-checked offset (unsigned) for a Timestamp. A core::time::Duration allows only +’ve offsets

type Output = Result<Timestamp, TimestampError>

The resulting type after applying the + operator.

pub fn add(self, rhs: D) -> <Timestamp as Add<D>>::Output

Performs the + operation.

impl Clone for Timestamp

pub 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

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Timestamp

pub fn deserialize<__D>(
    __deserializer: __D
) -> Result<Timestamp, <__D as Deserializer<'de>>::Error> where
    __D: Deserializer<'de>, 

Deserialize this value from the given Serde deserializer.

impl Display for Timestamp

Display as RFC3339 Date+Time for sane value ranges (0000-9999AD). Beyond that, format as (seconds, nanoseconds) tuple (output and parsing of large +/- years is unreliable).

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

Formats the value using the given formatter.

impl Eq for Timestamp

impl<'_> From<&'_ DateTime<Utc>> for Timestamp

pub fn from(t: &DateTime<Utc>) -> Timestamp

Performs the conversion.

impl From<DateTime<Utc>> for Timestamp

pub fn from(t: DateTime<Utc>) -> Timestamp

Performs the conversion.

impl From<i32> for Timestamp

pub fn from(secs: i32) -> Timestamp

Performs the conversion.

impl From<i64> for Timestamp

Infallible conversions into a Timestamp. The only infallible ways to create a Timestamp are from a Unix timestamp, or normalize with a timestamp and nanoseconds, or converting from a DateTime.

pub fn from(secs: i64) -> Timestamp

Performs the conversion.

impl From<u32> for Timestamp

pub fn from(secs: u32) -> Timestamp

Performs the conversion.

impl FromStr for Timestamp

type Err = TimestampError

The associated error which can be returned from parsing.

pub fn from_str(t: &str) -> Result<Timestamp, <Timestamp as FromStr>::Err>

Parses a string s to return a value of this type.

impl Hash for Timestamp

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

Feeds this value into the given Hasher.

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

Feeds a slice of this type into the given Hasher.

impl Ord for Timestamp

pub 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

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

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

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

This method tests for !=.

impl PartialOrd<Timestamp> for Timestamp

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

pub fn serialize<__S>(
    &self,
    __serializer: __S
) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error> where
    __S: Serializer, 

Serialize this value into the given Serde serializer.

impl StructuralEq for Timestamp

impl StructuralPartialEq for Timestamp

impl<D> Sub<D> for Timestamp where
    D: Into<Duration>, 

Timestamp - core::time::Duration.

type Output = Result<Timestamp, TimestampError>

The resulting type after applying the - operator.

pub fn sub(self, rhs: D) -> <Timestamp as Sub<D>>::Output

Performs the - operation.

impl<'_, D> Sub<D> for &'_ Timestamp where
    D: Into<Duration>, 

type Output = Result<Timestamp, TimestampError>

The resulting type after applying the - operator.

pub fn sub(self, rhs: D) -> <&'_ Timestamp as Sub<D>>::Output

Performs the - operation.

impl Sub<Timestamp> for Timestamp

Distance between two Timestamps as a chrono::Duration (subject to overflow). A Timestamp represents a signed distance from the UNIX Epoch (1970-01-01T00:00:00Z). A chrono::Duration is limited to +/- i64::MIN/MAX milliseconds.

type Output = Result<Duration, TimestampError>

The resulting type after applying the - operator.

pub fn sub(self, rhs: Timestamp) -> <Timestamp as Sub<Timestamp>>::Output

Performs the - operation.

impl<'_> TryFrom<&'_ String> for Timestamp

type Error = TimestampError

The type returned in the event of a conversion error.

pub fn try_from(
    t: &String
) -> Result<Timestamp, <Timestamp as TryFrom<&'_ String>>::Error>

Performs the conversion.

impl<'_> TryFrom<&'_ Timestamp> for SerializedBytes

type Error = SerializedBytesError

The type returned in the event of a conversion error.

pub fn try_from(t: &Timestamp) -> Result<SerializedBytes, SerializedBytesError>

Performs the conversion.

impl<'_> TryFrom<&'_ Timestamp> for DateTime<Utc>

type Error = TimestampError

The type returned in the event of a conversion error.

pub fn try_from(
    t: &Timestamp
) -> Result<DateTime<Utc>, <DateTime<Utc> as TryFrom<&'_ Timestamp>>::Error>

Performs the conversion.

impl<'_> TryFrom<&'_ str> for Timestamp

type Error = TimestampError

The type returned in the event of a conversion error.

pub fn try_from(
    t: &str
) -> Result<Timestamp, <Timestamp as TryFrom<&'_ str>>::Error>

Performs the conversion.

impl TryFrom<SerializedBytes> for Timestamp

type Error = SerializedBytesError

The type returned in the event of a conversion error.

pub fn try_from(sb: SerializedBytes) -> Result<Timestamp, SerializedBytesError>

Performs the conversion.

impl TryFrom<String> for Timestamp

type Error = TimestampError

The type returned in the event of a conversion error.

pub fn try_from(
    t: String
) -> Result<Timestamp, <Timestamp as TryFrom<String>>::Error>

Performs the conversion.

impl TryFrom<Timestamp> for SerializedBytes

type Error = SerializedBytesError

The type returned in the event of a conversion error.

pub fn try_from(t: Timestamp) -> Result<SerializedBytes, SerializedBytesError>

Performs the conversion.

impl TryFrom<Timestamp> for DateTime<Utc>

type Error = TimestampError

The type returned in the event of a conversion error.

pub fn try_from(
    t: Timestamp
) -> Result<DateTime<Utc>, <DateTime<Utc> as TryFrom<Timestamp>>::Error>

Performs the conversion.