Struct Timestamp 

pub struct Timestamp { /* private fields */ }

A Unix timestamp with nanosecond precision.

This type represents a point in time as a number of seconds and nanoseconds elapsed since the Unix epoch (1970-01-01 00:00:00 UTC). Negative values represent times before the Unix epoch.

Implementations

impl Timestamp

pub const UNIX_EPOCH: Self

A Timestamp representing the Unix epoch (1970-01-01 00:00:00 UTC).

pub const MIN: Self

The minimum valid Timestamp.

The moment in time represented by this value may vary depending on the feature flags enabled.

pub const MAX: Self

The maximum valid Timestamp.

The moment in time represented by this value may vary depending on the feature flags enabled.

pub fn now() -> Self

Available on crate feature std only.

Create a new Timestamp representing the current moment in time.

assert!(Timestamp::now().year() >= 2019);

pub const fn new(seconds: i64, nanoseconds: u32) -> Result<Self, ComponentRange>

Create a Timestamp from the provided Unix timestamp in seconds and nanoseconds, returning an error if the resulting value is out of range.

assert!(Timestamp::new(0, 0).is_ok());
assert!(Timestamp::new(i64::MAX, 0).is_err());

pub const fn from_seconds(seconds: i64) -> Result<Self, ComponentRange>

Create a Timestamp from the provided Unix timestamp in seconds, returning an error if the resulting value is out of range.

assert!(Timestamp::from_seconds(0).is_ok());
assert!(Timestamp::from_seconds(i64::MAX).is_err());

pub const fn from_milliseconds( milliseconds: i64, ) -> Result<Self, ComponentRange>

Create a Timestamp from the provided Unix timestamp in milliseconds, returning an error if the resulting value is out of range.

assert!(Timestamp::from_milliseconds(0).is_ok());
assert!(Timestamp::from_milliseconds(i64::MAX).is_err());

pub const fn from_microseconds( microseconds: i128, ) -> Result<Self, ComponentRange>

Create a Timestamp from the provided Unix timestamp in microseconds, returning an error if the resulting value is out of range.

assert!(Timestamp::from_microseconds(0).is_ok());
assert!(Timestamp::from_microseconds(i128::MAX).is_err());

pub const fn from_nanoseconds(nanoseconds: i128) -> Result<Self, ComponentRange>

Create a Timestamp from the provided Unix timestamp in nanoseconds, returning an error if the resulting value is out of range.

assert!(Timestamp::from_nanoseconds(0).is_ok());
assert!(Timestamp::from_nanoseconds(i128::MAX).is_err());

pub const fn to_offset(self, offset: UtcOffset) -> OffsetDateTime

Convert the Timestamp to an OffsetDateTime at the provided offset.

assert_eq!(timestamp!(1_546_398_245).to_offset(offset!(+1)).hour(), 4);

Panics

This panics if the resulting date-time with the provided offset is outside the supported range. Consider using checked_to_offset for a non-panicking alternative.

pub const fn checked_to_offset( self, offset: UtcOffset, ) -> Option<OffsetDateTime>

Convert the Timestamp to an OffsetDateTime with the provided offset, returning None if the resulting value is out of range.

assert!(
    timestamp!(1_546_398_245)
        .checked_to_offset(offset!(+1))
        .is_some()
);

pub const fn to_utc(self) -> UtcDateTime

Convert the Timestamp to a UtcDateTime.

assert_eq!(timestamp!(1_546_398_245).to_utc(), utc_datetime!(2019-01-02 3:04:05));

pub const fn as_seconds(self) -> i64

Get the number of seconds since the Unix epoch.

Negative values represent moments before the Unix epoch.

assert_eq!(timestamp!(1_546_398_245).as_seconds(), 1_546_398_245);

pub const fn as_milliseconds(self) -> i64

Get the number of milliseconds since the Unix epoch.

Negative values represent moments before the Unix epoch.

assert_eq!(
    timestamp!(1_546_398_245.006).as_milliseconds(),
    1_546_398_245_006
);

pub const fn as_microseconds(self) -> i128

Get the number of microseconds since the Unix epoch.

Negative values represent moments before the Unix epoch.

assert_eq!(
    timestamp!(1_546_398_245.006_007).as_microseconds(),
    1_546_398_245_006_007
);

pub const fn as_nanoseconds(self) -> i128

Get the number of nanoseconds since the Unix epoch.

Negative values represent moments before the Unix epoch.

assert_eq!(
    timestamp!(1_546_398_245.006_007_008).as_nanoseconds(),
    1_546_398_245_006_007_008
);

pub const fn date(self) -> Date

Get the Date of the timestamp in UTC.

assert_eq!(timestamp!(1_546_398_245).date(), date!(2019-01-02));

pub const fn time(self) -> Time

Get the Time of the timestamp in UTC.

assert_eq!(timestamp!(1_546_398_245).time(), time!(3:04:05));

pub const fn year(self) -> i32

Get the year of the timestamp in UTC.

assert_eq!(timestamp!(1_546_398_245).year(), 2019);

pub const fn month(self) -> Month

Get the month of the timestamp in UTC.

assert_eq!(timestamp!(1_546_398_245).month(), Month::January);

pub const fn day(self) -> u8

Get the day of the month of the timestamp in UTC.

The returned value will always be in the range 1..=31.

assert_eq!(timestamp!(1_546_398_245).day(), 2);

pub const fn ordinal(self) -> u16

Get the day of the year of the timestamp in UTC.

The returned value will always be in the range 1..=366.

assert_eq!(timestamp!(1_546_398_245).ordinal(), 2);

pub const fn iso_week(self) -> u8

Get the ISO week number of the timestamp in UTC.

The returned value will always be in the range 1..=53.

assert_eq!(timestamp!(1_546_398_245).iso_week(), 1);

pub const fn sunday_based_week(self) -> u8

Get the Sunday-based week number of the timestamp in UTC.

The returned value will always be in the range 0..=53.

pub const fn monday_based_week(self) -> u8

Get the Monday-based week number of the timestamp in UTC.

The returned value will always be in the range 0..=53.

pub const fn to_calendar_date(self) -> (i32, Month, u8)

Get the calendar date (year, month, day) of the timestamp in UTC.

assert_eq!(
    timestamp!(1_546_398_245).to_calendar_date(),
    (2019, Month::January, 2)
);

pub const fn to_ordinal_date(self) -> (i32, u16)

Get the ordinal date (year, ordinal day) of the timestamp in UTC.

assert_eq!(timestamp!(1_546_398_245).to_ordinal_date(), (2019, 2));

pub const fn to_iso_week_date(self) -> (i32, u8, Weekday)

Get the ISO week date (year, week number, weekday) of the timestamp in UTC.

assert_eq!(
    timestamp!(1_546_398_245).to_iso_week_date(),
    (2019, 1, Weekday::Wednesday)
);

pub const fn weekday(self) -> Weekday

Get the weekday of the timestamp in UTC.

assert_eq!(timestamp!(1_546_398_245).weekday(), Weekday::Wednesday);

pub const fn to_julian_day(self) -> i32

Get the Julian day of the timestamp.

pub const fn as_hms(self) -> (u8, u8, u8)

Get the hours, minutes, and seconds of the timestamp in UTC.

assert_eq!(timestamp!(1_546_398_245).as_hms(), (3, 4, 5));

pub const fn as_hms_milli(self) -> (u8, u8, u8, u16)

Get the hours, minutes, seconds, and milliseconds of the timestamp in UTC.

assert_eq!(timestamp!(1_546_398_245.006).as_hms_milli(), (3, 4, 5, 6));

pub const fn as_hms_micro(self) -> (u8, u8, u8, u32)

Get the hours, minutes, seconds, and microseconds of the timestamp in UTC.

assert_eq!(
    timestamp!(1_546_398_245.006_007).as_hms_micro(),
    (3, 4, 5, 6_007)
);

pub const fn as_hms_nano(self) -> (u8, u8, u8, u32)

Get the hours, minutes, seconds, and nanoseconds of the timestamp in UTC.

assert_eq!(
    timestamp!(1_546_398_245.006_007_008).as_hms_nano(),
    (3, 4, 5, 6_007_008)
);

pub const fn hour(self) -> u8

Get the hour of the timestamp in UTC.

assert_eq!(timestamp!(1_546_398_245).hour(), 3);

pub const fn minute(self) -> u8

Get the minute of the timestamp in UTC.

assert_eq!(timestamp!(1_546_398_245).minute(), 4);

pub const fn second(self) -> u8

Get the second of the timestamp in UTC.

assert_eq!(timestamp!(1_546_398_245).second(), 5);

pub const fn millisecond(self) -> u16

Get the millisecond of the timestamp in UTC.

assert_eq!(timestamp!(1_546_398_245.006).millisecond(), 6);

pub const fn microsecond(self) -> u32

Get the microsecond of the timestamp in UTC.

assert_eq!(timestamp!(1_546_398_245.006_007).microsecond(), 6_007);

pub const fn nanosecond(self) -> u32

Get the nanosecond of the timestamp in UTC.

assert_eq!(
    timestamp!(1_546_398_245.006_007_008).nanosecond(),
    6_007_008
);

pub const fn checked_add(self, duration: Duration) -> Option<Self>

Checked addition of a Duration, returning None if the result is out of range.

assert_eq!(
    timestamp!(1_546_398_245).checked_add(1.days()),
    Some(timestamp!(1_546_484_645))
);
assert_eq!(
    timestamp!(1_546_398_245).checked_add((-1).days()),
    Some(timestamp!(1_546_311_845))
);

pub const fn checked_sub(self, duration: Duration) -> Option<Self>

Checked subtraction of a Duration, returning None if the result is out of range.

assert_eq!(
    timestamp!(1_546_398_245).checked_sub(1.days()),
    Some(timestamp!(1_546_311_845))
);
assert_eq!(
    timestamp!(1_546_398_245).checked_sub((-1).days()),
    Some(timestamp!(1_546_484_645))
);

pub const fn saturating_add(self, duration: Duration) -> Self

Saturating addition of a Duration.

Returns Timestamp::MAX or Timestamp::MIN if the result is out of range.

assert_eq!(
    timestamp!(1_546_398_245).saturating_add(1.days()),
    timestamp!(1_546_484_645)
);
assert_eq!(Timestamp::MAX.saturating_add(1.days()), Timestamp::MAX);
assert_eq!(Timestamp::MIN.saturating_add((-1).days()), Timestamp::MIN);

pub const fn saturating_sub(self, duration: Duration) -> Self

Saturating subtraction of a Duration.

Returns Timestamp::MAX or Timestamp::MIN if the result is out of range.

assert_eq!(
    timestamp!(1_546_398_245).saturating_sub(1.days()),
    timestamp!(1_546_311_845)
);
assert_eq!(Timestamp::MIN.saturating_sub(1.days()), Timestamp::MIN);
assert_eq!(Timestamp::MAX.saturating_sub((-1).days()), Timestamp::MAX);

impl Timestamp

Methods that replace part of the Timestamp.

pub const fn replace_time(self, time: Time) -> Self

Replace the time, preserving the date.

assert_eq!(
    timestamp!(1_546_398_245).replace_time(time!(12:34:56)),
    timestamp!(1_546_432_496)
);

pub const fn replace_date(self, date: Date) -> Self

Replace the date, preserving the time.

assert_eq!(
    timestamp!(1_546_398_245).replace_date(date!(2020-01-02)),
    timestamp!(1_577_934_245)
);

pub const fn replace_year(self, year: i32) -> Result<Self, ComponentRange>

Replace the year, preserving the month and day. If the date is February 29 and the resulting year is not a leap year, an error is returned.

assert_eq!(
    timestamp!(1_546_398_245).replace_year(2020),
    Ok(timestamp!(1_577_934_245))
);
assert!(timestamp!(1_546_398_245).replace_year(-1_000_000).is_err()); // -1_000_000 isn't a valid year
assert!(timestamp!(1_546_398_245).replace_year(1_000_000).is_err()); // 1_000_000 isn't a valid year

pub const fn replace_month(self, month: Month) -> Result<Self, ComponentRange>

Replace the month of the year, preserving the year and day. If the day is invalid for the resulting month, an error is returned.

assert_eq!(
    timestamp!(1_546_398_245).replace_month(Month::February),
    Ok(timestamp!(1_549_076_645))
);
assert!(
    timestamp!(1_548_817_445)
        .replace_month(Month::February)
        .is_err()
); // the day of the month is 30, which is invalid for February

pub const fn replace_day(self, day: u8) -> Result<Self, ComponentRange>

Replace the day of the month.

assert_eq!(
    timestamp!(1_546_398_245).replace_day(1),
    Ok(timestamp!(1_546_311_845))
);
assert!(timestamp!(1_546_398_245).replace_day(0).is_err()); // 00 isn't a valid day
assert!(timestamp!(1_546_398_245).replace_day(32).is_err()); // 32 isn't a valid day

pub const fn replace_ordinal(self, ordinal: u16) -> Result<Self, ComponentRange>

Replace the day of the year.

assert_eq!(
    timestamp!(1_546_398_245).replace_ordinal(1),
    Ok(timestamp!(1_546_311_845))
);
assert!(timestamp!(1_546_398_245).replace_ordinal(0).is_err()); // 0 isn't a valid day of the year
assert!(timestamp!(1_546_398_245).replace_ordinal(366).is_err()); // the timestamp is in 2019, which isn't a leap year

pub const fn replace_hour(self, hour: u8) -> Result<Self, ComponentRange>

Replace the clock hour.

assert_eq!(
    timestamp!(1_546_398_245).replace_hour(0),
    Ok(timestamp!(1_546_387_445))
);
assert!(timestamp!(1_546_398_245).replace_hour(24).is_err()); // 24 isn't a valid hour

pub const fn replace_minute(self, minute: u8) -> Result<Self, ComponentRange>

Replace the minutes within the hour.

assert_eq!(
    timestamp!(1_546_398_245).replace_minute(0),
    Ok(timestamp!(1_546_398_005))
);
assert!(timestamp!(1_546_398_245).replace_minute(60).is_err()); // 60 isn't a valid minute

pub const fn replace_second(self, second: u8) -> Result<Self, ComponentRange>

Replace the seconds within the minute.

assert_eq!(
    timestamp!(1_546_398_245).replace_second(0),
    Ok(timestamp!(1_546_398_240))
);
assert!(timestamp!(1_546_398_245).replace_second(60).is_err()); // 60 isn't a valid second

pub const fn replace_millisecond( self, millisecond: u16, ) -> Result<Self, ComponentRange>

Replace the milliseconds within the second.

assert_eq!(
    timestamp!(1_546_398_245.006).replace_millisecond(7),
    Ok(timestamp!(1_546_398_245.007))
);
assert!(
    timestamp!(1_546_398_245.006)
        .replace_millisecond(1_000)
        .is_err()
); // 1_000 isn't a valid millisecond

pub const fn replace_microsecond( self, microsecond: u32, ) -> Result<Self, ComponentRange>

Replace the microseconds within the second.

assert_eq!(
    timestamp!(1_546_398_245.006_007).replace_microsecond(123_456),
    Ok(timestamp!(1_546_398_245.123_456))
);
assert!(
    timestamp!(1_546_398_245.006_007)
        .replace_microsecond(1_000_000)
        .is_err()
); // 1_000_000 isn't a valid microsecond

pub const fn replace_nanosecond( self, nanosecond: u32, ) -> Result<Self, ComponentRange>

Replace the nanoseconds within the second.

assert_eq!(
    timestamp!(1_546_398_245.006_007_008).replace_nanosecond(123_456_789),
    Ok(timestamp!(1_546_398_245.123_456_789))
);
assert!(
    timestamp!(1_546_398_245.006_007_008)
        .replace_nanosecond(1_000_000_000)
        .is_err()
); // 1_000_000_000 isn't a valid nanosecond

impl Timestamp

pub fn format_into( self, output: &mut (impl Write + ?Sized), format: &(impl Formattable + ?Sized), ) -> Result<usize, Format>

Available on crate feature formatting only.

Format the Timestamp using the provided format description.

pub fn format( self, format: &(impl Formattable + ?Sized), ) -> Result<String, Format>

Available on crate feature formatting only.

Format the Timestamp using the provided format description.

let format = format_description!("[unix_timestamp]");
assert_eq!(timestamp!(1_546_398_245).format(&format)?, "1546398245");

impl Timestamp

pub fn parse( input: &str, description: &(impl Parsable + ?Sized), ) -> Result<Self, Parse>

Available on crate feature parsing only.

Parse a Timestamp from the input using the provided format description.

let format = format_description!("[unix_timestamp]");
assert_eq!(
    Timestamp::parse("1546398245", &format)?,
    timestamp!(1_546_398_245),
);

Trait Implementations

impl Add<Duration> for Timestamp

fn add(self, rhs: Duration) -> Self::Output

Panics

This may panic if an overflow occurs.

type Output = Timestamp

The resulting type after applying the + operator.

impl Add<Duration> for Timestamp

fn add(self, rhs: StdDuration) -> Self::Output

Panics

This may panic if an overflow occurs.

type Output = Timestamp

The resulting type after applying the + operator.

impl AddAssign<Duration> for Timestamp

fn add_assign(&mut self, rhs: Duration)

Panics

This may panic if an overflow occurs.

impl AddAssign<Duration> for Timestamp

fn add_assign(&mut self, rhs: StdDuration)

Panics

This may panic if an overflow occurs.

impl Arbitrary for Timestamp

Available on crate feature quickcheck only.

fn arbitrary(g: &mut Gen) -> Self

Return an arbitrary value.

fn shrink(&self) -> Box<dyn Iterator<Item = Self>>

Return an iterator of values that are smaller than itself.

impl Clone for Timestamp

fn clone(&self) -> Timestamp

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for Timestamp

impl Debug for Timestamp

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

Formats the value using the given formatter.

impl<'a> Deserialize<'a> for Timestamp

Available on crate feature serde only.

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>

where D: Deserializer<'a>,

Deserialize this value from the given Serde deserializer.

impl Display for Timestamp

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

Formats the value using the given formatter.

impl Distribution<Timestamp> for StandardUniform

Available on crate feature rand010 only.

fn sample<R>(&self, rng: &mut R) -> Timestamp

where R: Rng + ?Sized,

Generate a random value of T, using rng as the source of randomness.

fn sample_iter<R>(self, rng: R) -> Iter<Self, R, T>

where R: Rng, Self: Sized,

Create an iterator that generates random values of T, using rng as the source of randomness.

fn map<F, S>(self, func: F) -> Map<Self, F, T, S>

where F: Fn(T) -> S, Self: Sized,

Map sampled values to type S

impl Distribution<Timestamp> for Standard

Available on crate feature rand08 only.

fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> Timestamp

Generate a random value of T, using rng as the source of randomness.

fn sample_iter<R>(self, rng: R) -> DistIter<Self, R, T>

where R: Rng, Self: Sized,

Create an iterator that generates random values of T, using rng as the source of randomness.

fn map<F, S>(self, func: F) -> DistMap<Self, F, T, S>

where F: Fn(T) -> S, Self: Sized,

Create a distribution of values of ‘S’ by mapping the output of Self through the closure F

impl Distribution<Timestamp> for StandardUniform

Available on crate feature rand09 only.

fn sample<R>(&self, rng: &mut R) -> Timestamp

where R: Rng + ?Sized,

Generate a random value of T, using rng as the source of randomness.

fn sample_iter<R>(self, rng: R) -> Iter<Self, R, T>

where R: Rng, Self: Sized,

Create an iterator that generates random values of T, using rng as the source of randomness.

fn map<F, S>(self, func: F) -> Map<Self, F, T, S>

where F: Fn(T) -> S, Self: Sized,

Map sampled values to type S

impl Eq for Timestamp

impl From<OffsetDateTime> for Timestamp

fn from(datetime: OffsetDateTime) -> Self

Panics

This may panic if an overflow occurs.

impl From<SystemTime> for Timestamp

Available on crate feature std only.

fn from(datetime: SystemTime) -> Self

Panics

This may panic if an overflow occurs.

impl From<Timestamp> for OffsetDateTime

fn from(timestamp: Timestamp) -> Self

Converts to this type from the input type.

impl From<Timestamp> for SystemTime

Available on crate feature std only.

fn from(timestamp: Timestamp) -> Self

Panics

This may panic if an overflow occurs.

impl From<Timestamp> for UtcDateTime

fn from(timestamp: Timestamp) -> Self

Converts to this type from the input type.

impl From<UtcDateTime> for Timestamp

fn from(datetime: UtcDateTime) -> Self

Converts to this type from the input type.

impl Hash for Timestamp

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 Timestamp

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

Restrict a value to a certain interval.

impl PartialEq for Timestamp

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<OffsetDateTime> for Timestamp

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<SystemTime> for Timestamp

Available on crate feature std only.

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<Timestamp> for OffsetDateTime

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<Timestamp> for SystemTime

Available on crate feature std only.

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<Timestamp> for UtcDateTime

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<UtcDateTime> for Timestamp

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialOrd for Timestamp

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

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl PartialOrd<OffsetDateTime> for Timestamp

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

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl PartialOrd<SystemTime> for Timestamp

Available on crate feature std only.

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

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl PartialOrd<Timestamp> for OffsetDateTime

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

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl PartialOrd<Timestamp> for SystemTime

Available on crate feature std only.

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

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl PartialOrd<Timestamp> for UtcDateTime

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

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl PartialOrd<UtcDateTime> for Timestamp

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

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl Serialize for Timestamp

Available on crate feature serde only.

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.

impl Sub for Timestamp

type Output = Duration

The resulting type after applying the - operator.

fn sub(self, rhs: Self) -> Self::Output

Performs the - operation.

impl Sub<Duration> for Timestamp

fn sub(self, rhs: Duration) -> Self::Output

Panics

This may panic if an overflow occurs.

type Output = Timestamp

The resulting type after applying the - operator.

impl Sub<Duration> for Timestamp

fn sub(self, rhs: StdDuration) -> Self::Output

Panics

This may panic if an overflow occurs.

type Output = Timestamp

The resulting type after applying the - operator.

impl Sub<OffsetDateTime> for Timestamp

type Output = Duration

The resulting type after applying the - operator.

fn sub(self, rhs: OffsetDateTime) -> Self::Output

Performs the - operation.

impl Sub<SystemTime> for Timestamp

Available on crate feature std only.

type Output = Duration

The resulting type after applying the - operator.

fn sub(self, rhs: SystemTime) -> Self::Output

Performs the - operation.

impl Sub<Timestamp> for OffsetDateTime

type Output = Duration

The resulting type after applying the - operator.

fn sub(self, rhs: Timestamp) -> Self::Output

Performs the - operation.

impl Sub<Timestamp> for SystemTime

Available on crate feature std only.

type Output = Duration

The resulting type after applying the - operator.

fn sub(self, rhs: Timestamp) -> Self::Output

Performs the - operation.

impl Sub<Timestamp> for UtcDateTime

type Output = Duration

The resulting type after applying the - operator.

fn sub(self, rhs: Timestamp) -> Self::Output

Performs the - operation.

impl Sub<UtcDateTime> for Timestamp

type Output = Duration

The resulting type after applying the - operator.

fn sub(self, rhs: UtcDateTime) -> Self::Output

Performs the - operation.

impl SubAssign<Duration> for Timestamp

fn sub_assign(&mut self, rhs: Duration)

Panics

This may panic if an overflow occurs.

impl SubAssign<Duration> for Timestamp

fn sub_assign(&mut self, rhs: StdDuration)

Panics

This may panic if an overflow occurs.

impl TryFrom<Parsed> for Timestamp

Available on crate feature parsing only.

type Error = TryFromParsed

The type returned in the event of a conversion error.

fn try_from(parsed: Parsed) -> Result<Self, Self::Error>

Performs the conversion.