Struct Timestamp 

#[repr(C)]
pub struct Timestamp {
    padding: Padding,
    nanoseconds: ru32<0, 999_999_999>,
    seconds: ri64<{ _ }, { _ }>,
}

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.

Fields

padding: Padding

nanoseconds: ru32<0, 999_999_999>

seconds: ri64<{ _ }, { _ }>

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.

const fn as_i128(self) -> i128

pub fn now() -> Self

Create a new Timestamp representing the current moment in time.

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

pub(crate) const fn new_ranged( seconds: ri64<{ _ }, { _ }>, nanoseconds: ru32<0, 999_999_999>, ) -> Self

Create a Timestamp from the provided seconds and nanoseconds values that are known to be in range.

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(crate) const fn as_parts_ranged( self, ) -> (ri64<{ _ }, { _ }>, ru32<0, 999_999_999>)

Get the seconds and nanoseconds of the timestamp as ranged values.

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));

const fn year_leap_ordinal(self) -> (i32, bool, u16)

Compute the year, leap year status, and ordinal day of the timestamp in UTC.

This algorithm is essentially identical to Date::from_julian_day_unchecked. Instead of returning Date, it returns the components as a tuple. By not bitpacking the values, it allows the compiler to see through the function boundary and better optimize methods.

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.

assert_eq!(timestamp!(1_546_398_245).sunday_based_week(), 0);

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.

assert_eq!(timestamp!(1_546_398_245).monday_based_week(), 0);

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.

assert_eq!(timestamp!(1_546_398_245).to_julian_day(), 2_458_486);

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
);

const fn add(self, duration: Duration) -> Result<Self, Overflow>

Add a Duration to the timestamp. Returns Overflow::Positive or Overflow::Negative if the result is out of range.

const fn sub(self, duration: Duration) -> Result<Self, Overflow>

Subtract a Duration from the timestamp. Returns Overflow::Positive or Overflow::Negative if the result is out of range.

const fn add_std(self, duration: StdDuration) -> Result<Self, Overflow>

Add a std::time::Duration to the timestamp. Returns Overflow::Positive or Overflow::Negative if the result is out of range.

const fn sub_std(self, duration: StdDuration) -> Result<Self, Overflow>

Subtract a std::time::Duration from the timestamp. Returns Overflow::Positive or Overflow::Negative if the result is out of range.

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

const fn replace_nanosecond_ranged( self, new_nanos: ru32<0, 999_999_999>, ) -> Self

Replace the nanoseconds within the second using a range-bounded integer to avoid range checks.

impl Timestamp

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

Format the Timestamp using the provided format description.

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

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>

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),
);

pub fn parse_with_defaults( input: &[u8], description: &(impl Parsable + ?Sized), defaults: Parsed, ) -> Result<Self, Parse>

Parse a Timestamp from the input using the provided format description and default values.

let format = format_description!("[year]-[month]-[day]");
let defaults = Parsed::new().with_hour_24(0).expect("0 is a valid hour");
assert_eq!(
    Timestamp::parse_with_defaults(b"2020-01-02", &format, defaults)?,
    timestamp!(1_577_923_200)
);

impl Timestamp

const DISPLAY_BUFFER_SIZE: usize = 25

The maximum number of bytes that the fmt_into_buffer method will write, which is also used by the Display implementation.

pub(crate) fn fmt_into_buffer(self, buf: &mut [MaybeUninit<u8>; 25]) -> usize

Format the Timestamp into the provided buffer, returning the number of bytes written.

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

const SUPPLIES_DATE: bool = true

Whether the type can provide date components, indicating that date-related methods can be called.

const SUPPLIES_TIME: bool = true

Whether the type can provide time components, indicating that time-related methods can be called.

const SUPPLIES_OFFSET: bool = true

Whether the type can provide offset components, indicating that offset-related methods can be called.

const SUPPLIES_TIMESTAMP: bool = true

Whether the type can provide timestamp components, indicating that timestamp-related methods can be called.

type State = TimestampState

The state type used by the provider, allowing for caching of computed values.

fn day(&self, state: &mut Self::State) -> ru8<1, 31>

Obtain the day of the month.

fn month(&self, state: &mut Self::State) -> Month

Obtain the month of the year.

fn ordinal(&self, state: &mut Self::State) -> ru16<1, 366>

Obtain the ordinal day of the year.

fn weekday(&self, state: &mut Self::State) -> Weekday

Obtain the day of the week.

fn iso_week_number(&self, state: &mut Self::State) -> ru8<1, 53>

Obtain the ISO week number.

fn monday_based_week(&self, state: &mut Self::State) -> ru8<0, 53>

Obtain the Monday-based week number.

fn sunday_based_week(&self, state: &mut Self::State) -> ru8<0, 53>

Obtain the Sunday-based week number.

fn calendar_year(&self, state: &mut Self::State) -> ri32<-999_999, 999_999>

Obtain the calendar year.

fn iso_year(&self, state: &mut Self::State) -> ri32<-999_999, 999_999>

Obtain the ISO week-based year.

fn hour(&self, state: &mut Self::State) -> ru8<0, { _ }>

Obtain the hour within the day.

fn minute(&self, state: &mut Self::State) -> ru8<0, { _ }>

Obtain the minute within the hour.

fn period(&self, state: &mut Self::State) -> Period

Obtain the period of the day (AM/PM).

fn second(&self, state: &mut Self::State) -> ru8<0, { _ }>

Obtain the second within the minute.

fn nanosecond(&self, _: &mut Self::State) -> ru32<0, { _ }>

Obtain the nanosecond within the second.

fn offset_is_negative(&self, _: &mut Self::State) -> bool

Obtain whether the offset is negative.

fn offset_is_utc(&self, _: &mut Self::State) -> bool

Obtain whether the offset is UTC.

fn offset_hour(&self, _: &mut Self::State) -> ri8<-25, 25>

Obtain the hour component of the UTC offset.

fn offset_minute(&self, _: &mut Self::State) -> ri8<{ _ }, { _ }>

Obtain the minute component of the UTC offset.

fn offset_second(&self, _: &mut Self::State) -> ri8<{ _ }, { _ }>

Obtain the second component of the UTC offset.

fn unix_timestamp_seconds(&self, _: &mut Self::State) -> i64

Obtain the Unix timestamp in seconds.

fn unix_timestamp_milliseconds(&self, _: &mut Self::State) -> i64

Obtain the Unix timestamp in milliseconds.

fn unix_timestamp_microseconds(&self, _: &mut Self::State) -> i128

Obtain the Unix timestamp in microseconds.

fn unix_timestamp_nanoseconds(&self, _: &mut Self::State) -> i128

Obtain the Unix timestamp in nanoseconds.

impl Debug for Timestamp

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

Formats the value using the given formatter.

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

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 From<OffsetDateTime> for Timestamp

fn from(datetime: OffsetDateTime) -> Self

Panics

This may panic if an overflow occurs.

impl From<SystemTime> for Timestamp

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

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

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

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

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

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

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

where S: Serializer,

Serialize this value into the given Serde serializer.

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

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

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

type Output = Duration

The resulting type after applying the - operator.

fn sub(self, rhs: Self) -> 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

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.

impl Copy for Timestamp

impl Eq for Timestamp