Struct holochain_types::prelude::Timestamp [−][src]
Expand description
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
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
Implementations
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 ))
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.
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 )));
Subtracts a chrono::Duration from a 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);
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 )));
Convert this timestamp to fit into a sqlite integer which is an i64. The value will be clamped between 0 and i64::MAX.
Trait Implementations
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
pub fn deserialize<__D>(
__deserializer: __D
) -> Result<Timestamp, <__D as Deserializer<'de>>::Error> where
__D: Deserializer<'de>,
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. Read more
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).
Performs the conversion.
Performs the conversion.
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
This method returns an ordering between self
and other
values if one exists. Read more
This method tests less than (for self
and other
) and is used by the <
operator. Read more
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
This method tests greater than (for self
and other
) and is used by the >
operator. Read more
pub fn serialize<__S>(
&self,
__serializer: __S
) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error> where
__S: Serializer,
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. Read more
Timestamp - core::time::Duration.
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 Error = SerializedBytesError
type Error = SerializedBytesError
The type returned in the event of a conversion error.
Performs the conversion.
type Error = SerializedBytesError
type Error = SerializedBytesError
The type returned in the event of a conversion error.
Performs the conversion.
type Error = SerializedBytesError
type Error = SerializedBytesError
The type returned in the event of a conversion error.
Performs the conversion.
Auto Trait Implementations
impl RefUnwindSafe for Timestamp
impl UnwindSafe for Timestamp
Blanket Implementations
fn type_id_compat(&self) -> TypeId
fn type_id_compat(&self) -> TypeId
TODO: once 1.33.0 is the minimum supported compiler version, remove Any::type_id_compat and use StdAny::type_id instead. https://github.com/rust-lang/rust/issues/27745 Read more
Mutably borrows from an owned value. Read more
Compare self to key
and return true
if they are equal.
fn with_context(self, otel_cx: Context) -> WithContext<Self>
fn with_context(self, otel_cx: Context) -> WithContext<Self>
fn with_current_context(self) -> WithContext<Self>
fn with_current_context(self) -> WithContext<Self>
Instruments this type with the provided Span
, returning an
Instrumented
wrapper. Read more
Instruments this type with the provided Span
, returning an
Instrumented
wrapper. Read more
type Output = T
type Output = T
Should always be Self
pub fn vzip(self) -> V
Attaches the provided Subscriber
to this type, returning a
WithDispatch
wrapper. Read more
Attaches the current default Subscriber
to this type, returning a
WithDispatch
wrapper. Read more
impl<T> AutoBTreeMapKey for T where
T: Serialize + DeserializeOwned + Clone + PartialOrd<T> + Ord,
impl<T> AutoHashMapKey for T where
T: Serialize + DeserializeOwned + Clone + Hash + PartialEq<T> + Eq,