Struct massa_time::MassaTime

pub struct MassaTime(pub(crate) u64);

Time structure used everywhere. milliseconds since 01/01/1970.

Tuple Fields

0: u64

Implementations

impl MassaTime

pub const fn from_millis(value: u64) -> Self

Conversion from u64, representing timestamp in milliseconds.

let time : MassaTime = MassaTime::from_millis(42);

pub const EPSILON: MassaTime = _

Smallest time interval

pub fn now() -> Self

Gets current UNIX timestamp (resolution: milliseconds).

let now_duration : Duration = SystemTime::now().duration_since(UNIX_EPOCH).unwrap();
let now_massa_time : MassaTime = MassaTime::now();
let converted:MassaTime = MassaTime::from_millis(now_duration.as_millis() as u64);
assert!(max(now_massa_time.saturating_sub(converted), converted.saturating_sub(now_massa_time)) < MassaTime::from_millis(100))

pub fn to_duration(&self) -> Duration

Conversion to std::time::Duration.

let duration: Duration = Duration::from_millis(42);
let time : MassaTime = MassaTime::from_millis(42);
let res: Duration = time.to_duration();
assert_eq!(res, duration);

pub const fn as_millis(&self) -> u64

Conversion to u64, representing milliseconds.

let time : MassaTime = MassaTime::from_millis(42);
let res: u64 = time.as_millis();
assert_eq!(res, 42);

pub fn estimate_instant(self) -> Result<Instant, TimeError>

let (cur_timestamp, cur_instant): (MassaTime, Instant) = (MassaTime::now(), Instant::now());
let massa_time_instant: Instant = cur_timestamp.estimate_instant().unwrap();
assert!(max(
    massa_time_instant.saturating_duration_since(cur_instant),
    cur_instant.saturating_duration_since(massa_time_instant)
) < std::time::Duration::from_millis(10))

pub fn saturating_sub(self, t: MassaTime) -> Self

let time_1 : MassaTime = MassaTime::from_millis(42);
let time_2 : MassaTime = MassaTime::from_millis(7);
let res : MassaTime = time_1.saturating_sub(time_2);
assert_eq!(res, MassaTime::from_millis(42-7))

pub fn saturating_add(self, t: MassaTime) -> Self

let time_1 : MassaTime = MassaTime::from_millis(42);
let time_2 : MassaTime = MassaTime::from_millis(7);
let res : MassaTime = time_1.saturating_add(time_2);
assert_eq!(res, MassaTime::from_millis(42+7))

pub fn checked_sub(self, t: MassaTime) -> Result<Self, TimeError>

let time_1 : MassaTime = MassaTime::from_millis(42);
let time_2 : MassaTime = MassaTime::from_millis(7);
let res : MassaTime = time_1.checked_sub(time_2).unwrap();
assert_eq!(res, MassaTime::from_millis(42-7))

pub fn checked_add(self, t: MassaTime) -> Result<Self, TimeError>

let time_1 : MassaTime = MassaTime::from_millis(42);
let time_2 : MassaTime = MassaTime::from_millis(7);
let res : MassaTime = time_1.checked_add(time_2).unwrap();
assert_eq!(res, MassaTime::from_millis(42+7))

pub fn checked_div_time(self, t: MassaTime) -> Result<u64, TimeError>

let time_1 : MassaTime = MassaTime::from_millis(42);
let time_2 : MassaTime = MassaTime::from_millis(7);
let res : u64 = time_1.checked_div_time(time_2).unwrap();
assert_eq!(res,42/7)

pub fn checked_div_u64(self, n: u64) -> Result<MassaTime, TimeError>

let time_1 : MassaTime = MassaTime::from_millis(42);
let res : MassaTime = time_1.checked_div_u64(7).unwrap();
assert_eq!(res,MassaTime::from_millis(42/7))

pub const fn saturating_mul(self, n: u64) -> MassaTime

let time_1 : MassaTime = MassaTime::from_millis(42);
let res : MassaTime = time_1.saturating_mul(7);
assert_eq!(res,MassaTime::from_millis(42*7))

pub fn checked_mul(self, n: u64) -> Result<Self, TimeError>

let time_1 : MassaTime = MassaTime::from_millis(42);
let res : MassaTime = time_1.checked_mul(7).unwrap();
assert_eq!(res,MassaTime::from_millis(42*7))

pub fn checked_rem_time(self, t: MassaTime) -> Result<Self, TimeError>

let time_1 : MassaTime = MassaTime::from_millis(42);
let time_2 : MassaTime = MassaTime::from_millis(7);
let res : MassaTime = time_1.checked_rem_time(time_2).unwrap();
assert_eq!(res,MassaTime::from_millis(42%7))

pub fn checked_rem_u64(self, n: u64) -> Result<Self, TimeError>

let time_1 : MassaTime = MassaTime::from_millis(42);
let res : MassaTime = time_1.checked_rem_u64(7).unwrap();
assert_eq!(res,MassaTime::from_millis(42%7))

pub fn abs_diff(&self, t: MassaTime) -> MassaTime

let time1 = MassaTime::from_millis(42);
let time2 = MassaTime::from_millis(84);

assert_eq!(time1.abs_diff(time2), MassaTime::from_millis(42));
assert_eq!(time2.abs_diff(time1), MassaTime::from_millis(42));

pub fn format_instant(&self) -> String

let massa_time : MassaTime = MassaTime::from_millis(1_640_995_200_000);
assert_eq!(massa_time.format_instant(), String::from("2022-01-01T00:00:00Z"))

pub fn format_duration(&self) -> Result<String, TimeError>

let massa_time : MassaTime = MassaTime::from_millis(1000*( 8 * 24*60*60 + 1 * 60*60 + 3 * 60 + 6 ));
assert_eq!(massa_time.format_duration().unwrap(), String::from("8 days, 1 hours, 3 minutes, 6 seconds"))

pub fn from_utc_ymd_hms( year: i32, month: u8, day: u8, hour: u8, minute: u8, second: u8, ) -> Result<MassaTime, TimeError>

let massa_time : MassaTime = MassaTime::from_utc_ymd_hms(2022, 2, 5, 22, 50, 40).unwrap();
assert_eq!(massa_time.format_instant(), String::from("2022-02-05T22:50:40Z"))

pub fn days_hours_mins_secs(&self) -> Result<(i64, i64, i64, i64), TimeError>

let massa_time = MassaTime::from_millis(1000 * ( 8 * 24*60*60 + 1 * 60*60 + 3 * 60 + 6 ));
let (days, hours, mins, secs) = massa_time.days_hours_mins_secs().unwrap();
assert_eq!(days, 8);
assert_eq!(hours, 1);
assert_eq!(mins, 3);
assert_eq!(secs, 6);

pub fn max() -> MassaTime

Get max MassaTime value

Trait Implementations

impl Clone for MassaTime

fn clone(&self) -> MassaTime

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for MassaTime

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for MassaTime

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Deserializer<MassaTime> for MassaTimeDeserializer

fn deserialize<'a, E: ParseError<&'a [u8]> + ContextError<&'a [u8]>>( &self, buffer: &'a [u8], ) -> IResult<&'a [u8], MassaTime, E>

use std::ops::Bound::Included;
use massa_serialization::{Serializer, Deserializer, DeserializeError};
use massa_time::{MassaTime, MassaTimeSerializer, MassaTimeDeserializer};

let time: MassaTime = MassaTime::from_millis(30);
let mut serialized = Vec::new();
let serializer = MassaTimeSerializer::new();
let deserializer = MassaTimeDeserializer::new((Included(MassaTime::from_millis(0)), Included(MassaTime::from_millis(u64::MAX))));
serializer.serialize(&time, &mut serialized).unwrap();
let (rest, time_deser) = deserializer.deserialize::<DeserializeError>(&serialized).unwrap();
assert!(rest.is_empty());
assert_eq!(time, time_deser);

impl Display for MassaTime

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

Formats the value using the given formatter.

impl From<MassaTime> for Duration

fn from(value: MassaTime) -> Self

Conversion from massa_time to duration, representing timestamp in milliseconds.

let duration: Duration = Duration::from_millis(42);
let time : MassaTime = MassaTime::from_millis(42);
let res: Duration = time.into();
assert_eq!(res, duration);

impl From<MassaTime> for NativeTime

fn from(value: MassaTime) -> Self

Converts to this type from the input type.

impl Hash for MassaTime

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 Ord for MassaTime

fn cmp(&self, other: &MassaTime) -> 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 + PartialOrd,

Restrict a value to a certain interval.

impl PartialEq for MassaTime

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

fn partial_cmp(&self, other: &MassaTime) -> 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 Serialize for MassaTime

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Serializer<MassaTime> for MassaTimeSerializer

fn serialize( &self, value: &MassaTime, buffer: &mut Vec<u8>, ) -> Result<(), SerializeError>

use std::ops::Bound::Included;
use massa_serialization::Serializer;
use massa_time::{MassaTime, MassaTimeSerializer};

let time: MassaTime = MassaTime::from_millis(30);
let mut serialized = Vec::new();
let serializer = MassaTimeSerializer::new();
serializer.serialize(&time, &mut serialized).unwrap();

impl Copy for MassaTime

impl Eq for MassaTime

impl StructuralPartialEq for MassaTime