Struct humantime::Timestamp

pub struct Timestamp(_);

A wrapper for SystemTime that has FromStr implementation

This is useful if you want to use it somewhere where FromStr is expected.

See parse_rfc3339_weak for the description of the format. The “weak” format is used as it’s more pemissive for human input as this is the expected use of the type (e.g. command-line parsing).

Example

use std::time::SystemTime;
let x: SystemTime;
x = "2018-02-16T00:31:37Z".parse::<humantime::Timestamp>().unwrap().into();
assert_eq!(humantime::format_rfc3339(x).to_string(), "2018-02-16T00:31:37Z");

Methods from Deref<Target = SystemTime>

pub const UNIX_EPOCH: SystemTime

pub fn duration_since(
    &self,
    earlier: SystemTime
) -> Result<Duration, SystemTimeError>

Returns the amount of time elapsed from an earlier point in time.

This function may fail because measurements taken earlier are not guaranteed to always be before later measurements (due to anomalies such as the system clock being adjusted either forwards or backwards). Instant can be used to measure elapsed time without this risk of failure.

If successful, Ok(Duration) is returned where the duration represents the amount of time elapsed from the specified measurement to this one.

Returns an Err if earlier is later than self, and the error contains how far from self the time is.

Examples

use std::time::SystemTime;

let sys_time = SystemTime::now();
let new_sys_time = SystemTime::now();
let difference = new_sys_time.duration_since(sys_time)
    .expect("Clock may have gone backwards");
println!("{:?}", difference);

pub fn elapsed(&self) -> Result<Duration, SystemTimeError>

Returns the difference between the clock time when this system time was created, and the current clock time.

This function may fail as the underlying system clock is susceptible to drift and updates (e.g., the system clock could go backwards), so this function may not always succeed. If successful, Ok(Duration) is returned where the duration represents the amount of time elapsed from this time measurement to the current time.

To measure elapsed time reliably, use Instant instead.

Returns an Err if self is later than the current system time, and the error contains how far from the current system time self is.

Examples

use std::thread::sleep;
use std::time::{Duration, SystemTime};

let sys_time = SystemTime::now();
let one_sec = Duration::from_secs(1);
sleep(one_sec);
assert!(sys_time.elapsed().unwrap() >= one_sec);

pub fn checked_add(&self, duration: Duration) -> Option<SystemTime>

Returns Some(t) where t is the time self + duration if t can be represented as SystemTime (which means it’s inside the bounds of the underlying data structure), None otherwise.

pub fn checked_sub(&self, duration: Duration) -> Option<SystemTime>

Returns Some(t) where t is the time self - duration if t can be represented as SystemTime (which means it’s inside the bounds of the underlying data structure), None otherwise.

Trait Implementations

impl AsRef<SystemTime> for Timestamp

fn as_ref(&self) -> &SystemTime

Performs the conversion.

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

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

Formats the value using the given formatter.

impl Deref for Timestamp

type Target = SystemTime

The resulting type after dereferencing.

fn deref(&self) -> &SystemTime

Dereferences the value.

impl Display for Timestamp

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

Formats the value using the given formatter.

impl Eq for Timestamp

impl From<SystemTime> for Timestamp

fn from(dur: SystemTime) -> Timestamp

Performs the conversion.

impl FromStr for Timestamp

type Err = Error

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<Timestamp, Self::Err>

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

impl Into<SystemTime> for Timestamp

fn into(self) -> SystemTime

Performs the conversion.

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 ==.

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

This method tests for !=.

impl StructuralEq for Timestamp

impl StructuralPartialEq for Timestamp