# Struct std::time::SystemTime

1.8.0 · source ·

    pub struct SystemTime(/* private fields */);

Expand description

A measurement of the system clock, useful for talking to external entities like the file system or other processes.

Distinct from the `Instant` type, this time measurement is not monotonic. This means that you can save a file to the file system, then save another file to the file system, and the second file has a `SystemTime` measurement earlier than the first. In other words, an operation that happens after another operation in real time may have an earlier `SystemTime`!

Consequently, comparing two `SystemTime` instances to learn about the duration between them returns a `Result` instead of an infallible `Duration` to indicate that this sort of time drift may happen and needs to be handled.

Although a `SystemTime` cannot be directly inspected, the `UNIX_EPOCH` constant is provided in this module as an anchor in time to learn information about a `SystemTime`. By calculating the duration from this fixed point in time, a `SystemTime` can be converted to a human-readable time, or perhaps some other string representation.

The size of a `SystemTime` struct may vary depending on the target operating system.

A `SystemTime` does not count leap seconds. `SystemTime::now()`’s behaviour around a leap second is the same as the operating system’s wall clock. The precise behaviour near a leap second (e.g. whether the clock appears to run slow or fast, or stop, or jump) depends on platform and configuration, so should not be relied on.

Example:

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

    fn main() {
       let now = SystemTime::now();

       // we sleep for 2 seconds
       sleep(Duration::new(2, 0));
       match now.elapsed() {
           Ok(elapsed) => {
               // it prints '2'
               println!("{}", elapsed.as_secs());
           }
           Err(e) => {
               // an error occurred!
               println!("Error: {e:?}");
           }
       }
    }

Run

## Platform-specific behavior

The precision of `SystemTime` can depend on the underlying OS-specific time format. For example, on Windows the time is represented in 100 nanosecond intervals whereas Linux can represent nanosecond intervals.

The following system calls are currently being used by `now()` to find out the current time:

Platform | System call
--- | ---
SGX | `insecure_time` usercall. More information on timekeeping in SGX
UNIX | clock_gettime (Realtime Clock)
Darwin | clock_gettime (Realtime Clock)
VXWorks | clock_gettime (Realtime Clock)
SOLID | `SOLID_RTC_ReadTime`
WASI | __wasi_clock_time_get (Realtime Clock)
Windows | GetSystemTimePreciseAsFileTime / GetSystemTimeAsFileTime

Disclaimer: These system calls might change over time.

> Note: mathematical operations like `add` may panic if the underlying structure cannot represent the new point in time.

## Implementations§

source§

### impl SystemTime

1.28.0 · source

#### pub const UNIX_EPOCH: SystemTime = UNIX_EPOCH

An anchor in time which can be used to create new `SystemTime` instances or learn about where in time a `SystemTime` lies.

This constant is defined to be “1970-01-01 00:00:00 UTC” on all systems with respect to the system clock. Using `duration_since` on an existing `SystemTime` instance can tell how far away from this point in time a measurement lies, and using `UNIX_EPOCH + duration` can be used to create a `SystemTime` instance to represent another fixed point in time.

`duration_since(UNIX_EPOCH).unwrap().as_secs()` returns the number of non-leap seconds since the start of 1970 UTC. This is a POSIX `time_t` (as a `u64`), and is the same time representation as used in many Internet protocols.

##### Examples

    use std::time::SystemTime;

    match SystemTime::now().duration_since(SystemTime::UNIX_EPOCH) {
        Ok(n) => println!("1970-01-01 00:00:00 UTC was {} seconds ago!", n.as_secs()),
        Err(_) => panic!("SystemTime before UNIX EPOCH!"),
    }

Run
source

#### pub fn now() -> SystemTime

Returns the system time corresponding to “now”.

##### Examples

    use std::time::SystemTime;

    let sys_time = SystemTime::now();

Run
source

#### 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:?}");

Run
source

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

Returns the difference from this system time to 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 might 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);

Run
1.34.0 · source

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

1.34.0 · source

#### 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§

source§

### impl Add<Duration> for SystemTime

source§

#### fn add(self, dur: Duration) -> SystemTime

##### Panics

This function may panic if the resulting point in time cannot be represented by the underlying data structure. See `SystemTime::checked_add` for a version without panic.

§

#### type Output = SystemTime

The resulting type after applying the `+` operator.
1.9.0 · source§

### impl AddAssign<Duration> for SystemTime

source§

#### fn add_assign(&mut self, other: Duration)

Performs the `+=` operation. Read more
source§

### impl Clone for SystemTime

source§

#### fn clone(&self) -> SystemTime

Returns a copy of the value. Read more
1.0.0 · source§

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

Performs copy-assignment from `source`. Read more
source§

### impl Debug for SystemTime

source§

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

Formats the value using the given formatter. Read more
source§

### impl Hash for SystemTime

source§

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

Feeds this value into the given `Hasher`. Read more
1.3.0 · source§

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

Feeds a slice of this type into the given `Hasher`. Read more
source§

### impl Ord for SystemTime

source§

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

This method returns an `Ordering` between `self` and `other`. Read more
1.21.0 · source§

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

Compares and returns the maximum of two values. Read more
1.21.0 · source§

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

Compares and returns the minimum of two values. Read more
1.50.0 · source§

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

Restrict a value to a certain interval. Read more
source§

### impl PartialEq for SystemTime

source§

#### fn eq(&self, other: &SystemTime) -> bool

This method tests for `self` and `other` values to be equal, and is used by `==`.
1.0.0 · source§

#### 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.
source§

### impl PartialOrd for SystemTime

source§

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

This method returns an ordering between `self` and `other` values if one exists. Read more
1.0.0 · source§

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

This method tests less than (for `self` and `other`) and is used by the `<` operator. Read more
1.0.0 · source§

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

This method tests less than or equal to (for `self` and `other`) and is used by the `<=` operator. Read more
1.0.0 · source§

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

This method tests greater than (for `self` and `other`) and is used by the `>` operator. Read more
1.0.0 · source§

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

This method tests greater than or equal to (for `self` and `other`) and is used by the `>=` operator. Read more
source§

### impl Sub<Duration> for SystemTime

§

#### type Output = SystemTime

The resulting type after applying the `-` operator.
source§

#### fn sub(self, dur: Duration) -> SystemTime

Performs the `-` operation. Read more
1.9.0 · source§

### impl SubAssign<Duration> for SystemTime

source§

#### fn sub_assign(&mut self, other: Duration)

Performs the `-=` operation. Read more
source§

### impl Copy for SystemTime

source§

### impl Eq for SystemTime

source§

### impl StructuralEq for SystemTime

source§

### impl StructuralPartialEq for SystemTime

## Auto Trait Implementations§

§

### impl RefUnwindSafe for SystemTime

§

### impl Send for SystemTime

§

### impl Sync for SystemTime

§

### impl Unpin for SystemTime

§

### impl UnwindSafe for SystemTime

## Blanket Implementations§

source§

### impl<T> Any for Twhere T: 'static + ?Sized,

source§

#### fn type_id(&self) -> TypeId

Gets the `TypeId` of `self`. Read more
source§

### impl<T> Borrow<T> for Twhere T: ?Sized,

source§

#### fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
source§

### impl<T> BorrowMut<T> for Twhere T: ?Sized,

source§

#### fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
source§

### impl<T> From<T> for T

source§

#### fn from(t: T) -> T

Returns the argument unchanged.

source§

### impl<T, U> Into<U> for Twhere U: From<T>,

source§

#### fn into(self) -> U

Calls `U::from(self)`.

That is, this conversion is whatever the implementation of `From<T> for U` chooses to do.

source§

### impl<T> ToOwned for Twhere T: Clone,

§

#### type Owned = T

The resulting type after obtaining ownership.
source§

#### fn to_owned(&self) -> T

Creates owned data from borrowed data, usually by cloning. Read more
source§

#### fn clone_into(&self, target: &mut T)

Uses borrowed data to replace owned data, usually by cloning. Read more
source§

### impl<T, U> TryFrom<U> for Twhere U: Into<T>,

§

#### type Error = Infallible

The type returned in the event of a conversion error.
source§

#### fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
source§

### impl<T, U> TryInto<U> for Twhere U: TryFrom<T>,

§

#### type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
source§

#### fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.