sgx_tstd/src/time/mod.rs - incubator-teaclave-sgx-sdk - Git at Google

 // Copyright (C) 2017-2018 Baidu, Inc. All Rights Reserved.
 //
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions
 // are met:
 //
 //  * Redistributions of source code must retain the above copyright
 //    notice, this list of conditions and the following disclaimer.
 //  * Redistributions in binary form must reproduce the above copyright
 //    notice, this list of conditions and the following disclaimer in
 //    the documentation and/or other materials provided with the
 //    distribution.
 //  * Neither the name of Baidu, Inc., nor the names of its
 //    contributors may be used to endorse or promote products derived
 //    from this software without specific prior written permission.
 //
 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

 //! Temporal quantification.

 use core::fmt;
 use core::ops::{Add, Sub, AddAssign, SubAssign};
 use error::Error;
 use sys::time;
 use sys_common::FromInner;

 pub use self::duration::Duration;

 mod duration;

 /// A measurement of a monotonically nondecreasing clock.
 /// Opaque and useful only with `Duration`.
 ///
 /// Instants are always guaranteed to be no less than any previously measured
 /// instant when created, and are often useful for tasks such as measuring
 /// benchmarks or timing how long an operation takes.
 ///
 /// Note, however, that instants are not guaranteed to be **steady**.  In other
 /// words, each tick of the underlying clock may not be the same length (e.g.
 /// some seconds may be longer than others). An instant may jump forwards or
 /// experience time dilation (slow down or speed up), but it will never go
 /// backwards.
 ///
 /// Instants are opaque types that can only be compared to one another. There is
 /// no method to get "the number of seconds" from an instant. Instead, it only
 /// allows measuring the duration between two instants (or comparing two
 /// instants).
 ///
 /// The size of an `Instant` struct may vary depending on the target operating
 /// system.
 ///
 #[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
 pub struct Instant(time::Instant);

 /// 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.
 ///
 #[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
 pub struct SystemTime(time::SystemTime);

 /// An error returned from the `duration_since` and `elapsed` methods on
 /// `SystemTime`, used to learn how far in the opposite direction a system time
 /// lies.
 ///
 #[derive(Clone, Debug)]
 pub struct SystemTimeError(Duration);

 impl Instant {
     /// Returns an instant corresponding to "now".
     ///
     #[cfg(feature = "untrusted_time")]
     pub fn now() -> Instant {
         Instant(time::Instant::now())
     }

     /// Returns the amount of time elapsed from another instant to this one.
     ///
     /// # Panics
     ///
     /// This function will panic if `earlier` is later than `self`.
     ///
     pub fn duration_since(&self, earlier: Instant) -> Duration {
         self.0.sub_instant(&earlier.0)
     }

     /// Returns the amount of time elapsed since this instant was created.
     ///
     /// # Panics
     ///
     /// This function may panic if the current time is earlier than this
     /// instant, which is something that can happen if an `Instant` is
     /// produced synthetically.
     ///
     #[cfg(feature = "untrusted_time")]
     pub fn elapsed(&self) -> Duration {
         Instant::now() - *self
     }
 }

 impl Add<Duration> for Instant {
     type Output = Instant;

     fn add(self, other: Duration) -> Instant {
         Instant(self.0.add_duration(&other))
     }
 }

 impl AddAssign<Duration> for Instant {
     fn add_assign(&mut self, other: Duration) {
         *self = *self + other;
     }
 }

 impl Sub<Duration> for Instant {
     type Output = Instant;

     fn sub(self, other: Duration) -> Instant {
         Instant(self.0.sub_duration(&other))
     }
 }

 impl SubAssign<Duration> for Instant {
     fn sub_assign(&mut self, other: Duration) {
         *self = *self - other;
     }
 }

 impl Sub<Instant> for Instant {
     type Output = Duration;

     fn sub(self, other: Instant) -> Duration {
         self.duration_since(other)
     }
 }

 impl fmt::Debug for Instant {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         self.0.fmt(f)
     }
 }

 impl SystemTime {
     /// 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.
     ///
     pub const UNIX_EPOCH: SystemTime = UNIX_EPOCH;
     /// Returns the system time corresponding to "now".
     ///
     #[cfg(feature = "untrusted_time")]
     pub fn now() -> SystemTime {
         SystemTime(time::SystemTime::now())
     }

     /// 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).
     ///
     /// 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.
     ///
     pub fn duration_since(&self, earlier: SystemTime)
                           -> Result<Duration, SystemTimeError> {
         self.0.sub_time(&earlier.0).map_err(SystemTimeError)
     }

     /// Returns the amount of time elapsed since this system time was created.
     ///
     /// 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.
     ///
     /// 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.
     ///
     #[cfg(feature = "untrusted_time")]
     pub fn elapsed(&self) -> Result<Duration, SystemTimeError> {
         SystemTime::now().duration_since(*self)
     }
 }

 impl Add<Duration> for SystemTime {
     type Output = SystemTime;

     fn add(self, dur: Duration) -> SystemTime {
         SystemTime(self.0.add_duration(&dur))
     }
 }

 impl AddAssign<Duration> for SystemTime {
     fn add_assign(&mut self, other: Duration) {
         *self = *self + other;
     }
 }

 impl Sub<Duration> for SystemTime {
     type Output = SystemTime;

     fn sub(self, dur: Duration) -> SystemTime {
         SystemTime(self.0.sub_duration(&dur))
     }
 }

 impl SubAssign<Duration> for SystemTime {
     fn sub_assign(&mut self, other: Duration) {
         *self = *self - other;
     }
 }

 impl fmt::Debug for SystemTime {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         self.0.fmt(f)
     }
 }

 /// 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.
 ///
 pub const UNIX_EPOCH: SystemTime = SystemTime(time::UNIX_EPOCH);

 impl SystemTimeError {
     /// Returns the positive duration which represents how far forward the
     /// second system time was from the first.
     ///
     /// A `SystemTimeError` is returned from the [`duration_since`] and [`elapsed`]
     /// methods of [`SystemTime`] whenever the second system time represents a point later
     /// in time than the `self` of the method call.
     ///
     pub fn duration(&self) -> Duration {
         self.0
     }
 }

 impl Error for SystemTimeError {
     fn description(&self) -> &str { "other time was not earlier than self" }
 }

 impl fmt::Display for SystemTimeError {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         write!(f, "second time provided was later than self")
     }
 }

 impl FromInner<time::SystemTime> for SystemTime {
     fn from_inner(time: time::SystemTime) -> SystemTime {
         SystemTime(time)
     }
 }
	// Copyright (C) 2017-2018 Baidu, Inc. All Rights Reserved.
	//
	// Redistribution and use in source and binary forms, with or without
	// modification, are permitted provided that the following conditions
	// are met:
	//
	// * Redistributions of source code must retain the above copyright
	// notice, this list of conditions and the following disclaimer.
	// * Redistributions in binary form must reproduce the above copyright
	// notice, this list of conditions and the following disclaimer in
	// the documentation and/or other materials provided with the
	// distribution.
	// * Neither the name of Baidu, Inc., nor the names of its
	// contributors may be used to endorse or promote products derived
	// from this software without specific prior written permission.
	//
	// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
	// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
	// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
	// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
	// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
	// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
	// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
	// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
	// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
	// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
	// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

	//! Temporal quantification.

	use core::fmt;
	use core::ops::{Add, Sub, AddAssign, SubAssign};
	use error::Error;
	use sys::time;
	use sys_common::FromInner;

	pub use self::duration::Duration;

	mod duration;

	/// A measurement of a monotonically nondecreasing clock.
	/// Opaque and useful only with `Duration`.
	///
	/// Instants are always guaranteed to be no less than any previously measured
	/// instant when created, and are often useful for tasks such as measuring
	/// benchmarks or timing how long an operation takes.
	///
	/// Note, however, that instants are not guaranteed to be steady. In other
	/// words, each tick of the underlying clock may not be the same length (e.g.
	/// some seconds may be longer than others). An instant may jump forwards or
	/// experience time dilation (slow down or speed up), but it will never go
	/// backwards.
	///
	/// Instants are opaque types that can only be compared to one another. There is
	/// no method to get "the number of seconds" from an instant. Instead, it only
	/// allows measuring the duration between two instants (or comparing two
	/// instants).
	///
	/// The size of an `Instant` struct may vary depending on the target operating
	/// system.
	///
	#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
	pub struct Instant(time::Instant);

	/// 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.
	///
	#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
	pub struct SystemTime(time::SystemTime);

	/// An error returned from the `duration_since` and `elapsed` methods on
	/// `SystemTime`, used to learn how far in the opposite direction a system time
	/// lies.
	///
	#[derive(Clone, Debug)]
	pub struct SystemTimeError(Duration);

	impl Instant {
	/// Returns an instant corresponding to "now".
	///
	#[cfg(feature = "untrusted_time")]
	pub fn now() -> Instant {
	Instant(time::Instant::now())
	}

	/// Returns the amount of time elapsed from another instant to this one.
	///
	/// # Panics
	///
	/// This function will panic if `earlier` is later than `self`.
	///
	pub fn duration_since(&self, earlier: Instant) -> Duration {
	self.0.sub_instant(&earlier.0)
	}

	/// Returns the amount of time elapsed since this instant was created.
	///
	/// # Panics
	///
	/// This function may panic if the current time is earlier than this
	/// instant, which is something that can happen if an `Instant` is
	/// produced synthetically.
	///
	#[cfg(feature = "untrusted_time")]
	pub fn elapsed(&self) -> Duration {
	Instant::now() - *self
	}
	}

	impl Add<Duration> for Instant {
	type Output = Instant;

	fn add(self, other: Duration) -> Instant {
	Instant(self.0.add_duration(&other))
	}
	}

	impl AddAssign<Duration> for Instant {
	fn add_assign(&mut self, other: Duration) {
	self = self + other;
	}
	}

	impl Sub<Duration> for Instant {
	type Output = Instant;

	fn sub(self, other: Duration) -> Instant {
	Instant(self.0.sub_duration(&other))
	}
	}

	impl SubAssign<Duration> for Instant {
	fn sub_assign(&mut self, other: Duration) {
	self = self - other;
	}
	}

	impl Sub<Instant> for Instant {
	type Output = Duration;

	fn sub(self, other: Instant) -> Duration {
	self.duration_since(other)
	}
	}

	impl fmt::Debug for Instant {
	fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
	self.0.fmt(f)
	}
	}

	impl SystemTime {
	/// 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.
	///
	pub const UNIX_EPOCH: SystemTime = UNIX_EPOCH;
	/// Returns the system time corresponding to "now".
	///
	#[cfg(feature = "untrusted_time")]
	pub fn now() -> SystemTime {
	SystemTime(time::SystemTime::now())
	}

	/// 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).
	///
	/// 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.
	///
	pub fn duration_since(&self, earlier: SystemTime)
	-> Result<Duration, SystemTimeError> {
	self.0.sub_time(&earlier.0).map_err(SystemTimeError)
	}

	/// Returns the amount of time elapsed since this system time was created.
	///
	/// 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.
	///
	/// 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.
	///
	#[cfg(feature = "untrusted_time")]
	pub fn elapsed(&self) -> Result<Duration, SystemTimeError> {
	SystemTime::now().duration_since(*self)
	}
	}

	impl Add<Duration> for SystemTime {
	type Output = SystemTime;

	fn add(self, dur: Duration) -> SystemTime {
	SystemTime(self.0.add_duration(&dur))
	}
	}

	impl AddAssign<Duration> for SystemTime {
	fn add_assign(&mut self, other: Duration) {
	self = self + other;
	}
	}

	impl Sub<Duration> for SystemTime {
	type Output = SystemTime;

	fn sub(self, dur: Duration) -> SystemTime {
	SystemTime(self.0.sub_duration(&dur))
	}
	}

	impl SubAssign<Duration> for SystemTime {
	fn sub_assign(&mut self, other: Duration) {
	self = self - other;
	}
	}

	impl fmt::Debug for SystemTime {
	fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
	self.0.fmt(f)
	}
	}

	/// 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.
	///
	pub const UNIX_EPOCH: SystemTime = SystemTime(time::UNIX_EPOCH);

	impl SystemTimeError {
	/// Returns the positive duration which represents how far forward the
	/// second system time was from the first.
	///
	/// A `SystemTimeError` is returned from the [`duration_since`] and [`elapsed`]
	/// methods of [`SystemTime`] whenever the second system time represents a point later
	/// in time than the `self` of the method call.
	///
	pub fn duration(&self) -> Duration {
	self.0
	}
	}

	impl Error for SystemTimeError {
	fn description(&self) -> &str { "other time was not earlier than self" }
	}

	impl fmt::Display for SystemTimeError {
	fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
	write!(f, "second time provided was later than self")
	}
	}

	impl FromInner<time::SystemTime> for SystemTime {
	fn from_inner(time: time::SystemTime) -> SystemTime {
	SystemTime(time)
	}
	}