Struct DateTime 

pub struct DateTime(pub OffsetDateTime);

An RFC 3339 date-time, the wire form of OpenAPI’s format: date-time.

Tuple Fields

0: OffsetDateTime

Implementations

impl DateTime

pub fn into_inner(self) -> OffsetDateTime

The wrapped time value.

impl DateTime

pub fn parse_strict(text: &str) -> Result<Self, ParseError>

Parse an RFC 3339 date-time exactly: YYYY-MM-DDTHH:MM:SS[.fraction](Z|±HH:MM), with an upper-case T and Z, a year from 0001, a real calendar day and no leap second.

pub fn parse_lenient(text: &str) -> Result<Self, ParseError>

As parse_strict, but seconds may be omitted (HH:MM), T and Z may be lower case (RFC 3339 §5.6) and the year may be 0000: every value a contract with a date-time format or its own pattern may carry.

impl DateTime

pub fn to_millis_string(&self) -> String

RFC 3339 with exactly three fractional digits (2024-01-01T00:00:00.000Z): the form a date-time takes where the contract’s pattern requires milliseconds.

Methods from Deref<Target = OffsetDateTime>

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

Convert the OffsetDateTime from the current UtcOffset to the provided UtcOffset.

assert_eq!(
    datetime!(2000-01-01 0:00 UTC)
        .to_offset(offset!(-1))
        .year(),
    1999,
);

// Let's see what time Sydney's new year's celebration is in New York and Los Angeles.

// Construct midnight on new year's in Sydney.
let sydney = datetime!(2000-01-01 0:00 +11);
let new_york = sydney.to_offset(offset!(-5));
let los_angeles = sydney.to_offset(offset!(-8));
assert_eq!(sydney.hour(), 0);
assert_eq!(new_york.hour(), 8);
assert_eq!(los_angeles.hour(), 5);

Panics

This method panics if the local date-time in the new offset is outside the supported range.

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

Convert the OffsetDateTime from the current UtcOffset to the provided UtcOffset, returning None if the date-time in the resulting offset is invalid.

assert_eq!(
    datetime!(2000-01-01 0:00 UTC)
        .checked_to_offset(offset!(-1))
        .unwrap()
        .year(),
    1999,
);
assert_eq!(
    PlainDateTime::MAX
        .assume_utc()
        .checked_to_offset(offset!(+1)),
    None,
);

pub fn to_utc(self) -> UtcDateTime

Convert the OffsetDateTime from the current UtcOffset to UTC, returning a UtcDateTime.

assert_eq!(
    datetime!(2000-01-01 0:00 +1)
        .to_utc()
        .year(),
    1999,
);

Panics

This method panics if the UTC date-time is outside the supported range.

pub fn checked_to_utc(self) -> Option<UtcDateTime>

Convert the OffsetDateTime from the current UtcOffset to UTC, returning None if the UTC date-time is invalid. Returns a UtcDateTime.

assert_eq!(
    datetime!(2000-01-01 0:00 +1)
        .checked_to_utc()
        .unwrap()
        .year(),
    1999,
);
assert_eq!(
    datetime!(9999-12-31 23:59:59 -1).checked_to_utc(),
    None,
);

pub fn offset(self) -> UtcOffset

Get the UtcOffset.

assert_eq!(datetime!(2019-01-01 0:00 UTC).offset(), offset!(UTC));
assert_eq!(datetime!(2019-01-01 0:00 +1).offset(), offset!(+1));

pub fn unix_timestamp(self) -> i64

Get the Unix timestamp.

assert_eq!(datetime!(1970-01-01 0:00 UTC).unix_timestamp(), 0);
assert_eq!(datetime!(1970-01-01 0:00 -1).unix_timestamp(), 3_600);

pub fn unix_timestamp_nanos(self) -> i128

Get the Unix timestamp in nanoseconds.

use time_macros::datetime;
assert_eq!(datetime!(1970-01-01 0:00 UTC).unix_timestamp_nanos(), 0);
assert_eq!(
    datetime!(1970-01-01 0:00 -1).unix_timestamp_nanos(),
    3_600_000_000_000,
);

pub fn date(self) -> Date

Get the Date in the stored offset.

assert_eq!(datetime!(2019-01-01 0:00 UTC).date(), date!(2019-01-01));
assert_eq!(
    datetime!(2019-01-01 0:00 UTC)
        .to_offset(offset!(-1))
        .date(),
    date!(2018-12-31),
);

pub fn time(self) -> Time

Get the Time in the stored offset.

assert_eq!(datetime!(2019-01-01 0:00 UTC).time(), time!(0:00));
assert_eq!(
    datetime!(2019-01-01 0:00 UTC)
        .to_offset(offset!(-1))
        .time(),
    time!(23:00)
);

pub fn year(self) -> i32

Get the year of the date in the stored offset.

assert_eq!(datetime!(2019-01-01 0:00 UTC).year(), 2019);
assert_eq!(
    datetime!(2019-12-31 23:00 UTC)
        .to_offset(offset!(+1))
        .year(),
    2020,
);
assert_eq!(datetime!(2020-01-01 0:00 UTC).year(), 2020);

pub fn month(self) -> Month

Get the month of the date in the stored offset.

assert_eq!(datetime!(2019-01-01 0:00 UTC).month(), Month::January);
assert_eq!(
    datetime!(2019-12-31 23:00 UTC)
        .to_offset(offset!(+1))
        .month(),
    Month::January,
);

pub fn day(self) -> u8

Get the day of the date in the stored offset.

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

assert_eq!(datetime!(2019-01-01 0:00 UTC).day(), 1);
assert_eq!(
    datetime!(2019-12-31 23:00 UTC)
        .to_offset(offset!(+1))
        .day(),
    1,
);

pub fn ordinal(self) -> u16

Get the day of the year of the date in the stored offset.

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

assert_eq!(datetime!(2019-01-01 0:00 UTC).ordinal(), 1);
assert_eq!(
    datetime!(2019-12-31 23:00 UTC)
        .to_offset(offset!(+1))
        .ordinal(),
    1,
);

pub fn iso_week(self) -> u8

Get the ISO week number of the date in the stored offset.

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

assert_eq!(datetime!(2019-01-01 0:00 UTC).iso_week(), 1);
assert_eq!(datetime!(2020-01-01 0:00 UTC).iso_week(), 1);
assert_eq!(datetime!(2020-12-31 0:00 UTC).iso_week(), 53);
assert_eq!(datetime!(2021-01-01 0:00 UTC).iso_week(), 53);

pub fn sunday_based_week(self) -> u8

Get the week number where week 1 begins on the first Sunday.

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

assert_eq!(datetime!(2019-01-01 0:00 UTC).sunday_based_week(), 0);
assert_eq!(datetime!(2020-01-01 0:00 UTC).sunday_based_week(), 0);
assert_eq!(datetime!(2020-12-31 0:00 UTC).sunday_based_week(), 52);
assert_eq!(datetime!(2021-01-01 0:00 UTC).sunday_based_week(), 0);

pub fn monday_based_week(self) -> u8

Get the week number where week 1 begins on the first Monday.

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

assert_eq!(datetime!(2019-01-01 0:00 UTC).monday_based_week(), 0);
assert_eq!(datetime!(2020-01-01 0:00 UTC).monday_based_week(), 0);
assert_eq!(datetime!(2020-12-31 0:00 UTC).monday_based_week(), 52);
assert_eq!(datetime!(2021-01-01 0:00 UTC).monday_based_week(), 0);

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

Get the year, month, and day.

assert_eq!(
    datetime!(2019-01-01 0:00 UTC).to_calendar_date(),
    (2019, Month::January, 1)
);

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

Get the year and ordinal day number.

assert_eq!(
    datetime!(2019-01-01 0:00 UTC).to_ordinal_date(),
    (2019, 1)
);

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

Get the ISO 8601 year, week number, and weekday.

assert_eq!(
    datetime!(2019-01-01 0:00 UTC).to_iso_week_date(),
    (2019, 1, Tuesday)
);
assert_eq!(
    datetime!(2019-10-04 0:00 UTC).to_iso_week_date(),
    (2019, 40, Friday)
);
assert_eq!(
    datetime!(2020-01-01 0:00 UTC).to_iso_week_date(),
    (2020, 1, Wednesday)
);
assert_eq!(
    datetime!(2020-12-31 0:00 UTC).to_iso_week_date(),
    (2020, 53, Thursday)
);
assert_eq!(
    datetime!(2021-01-01 0:00 UTC).to_iso_week_date(),
    (2020, 53, Friday)
);

pub fn weekday(self) -> Weekday

Get the weekday of the date in the stored offset.

assert_eq!(datetime!(2019-01-01 0:00 UTC).weekday(), Tuesday);
assert_eq!(datetime!(2019-02-01 0:00 UTC).weekday(), Friday);
assert_eq!(datetime!(2019-03-01 0:00 UTC).weekday(), Friday);

pub fn to_julian_day(self) -> i32

Get the Julian day for the date. The time is not taken into account for this calculation.

assert_eq!(datetime!(-4713-11-24 0:00 UTC).to_julian_day(), 0);
assert_eq!(datetime!(2000-01-01 0:00 UTC).to_julian_day(), 2_451_545);
assert_eq!(datetime!(2019-01-01 0:00 UTC).to_julian_day(), 2_458_485);
assert_eq!(datetime!(2019-12-31 0:00 UTC).to_julian_day(), 2_458_849);

pub fn to_hms(self) -> (u8, u8, u8)

Get the clock hour, minute, and second.

assert_eq!(datetime!(2020-01-01 0:00:00 UTC).to_hms(), (0, 0, 0));
assert_eq!(datetime!(2020-01-01 23:59:59 UTC).to_hms(), (23, 59, 59));

pub fn to_hms_milli(self) -> (u8, u8, u8, u16)

Get the clock hour, minute, second, and millisecond.

assert_eq!(
    datetime!(2020-01-01 0:00:00 UTC).to_hms_milli(),
    (0, 0, 0, 0)
);
assert_eq!(
    datetime!(2020-01-01 23:59:59.999 UTC).to_hms_milli(),
    (23, 59, 59, 999)
);

pub fn to_hms_micro(self) -> (u8, u8, u8, u32)

Get the clock hour, minute, second, and microsecond.

assert_eq!(
    datetime!(2020-01-01 0:00:00 UTC).to_hms_micro(),
    (0, 0, 0, 0)
);
assert_eq!(
    datetime!(2020-01-01 23:59:59.999_999 UTC).to_hms_micro(),
    (23, 59, 59, 999_999)
);

pub fn to_hms_nano(self) -> (u8, u8, u8, u32)

Get the clock hour, minute, second, and nanosecond.

assert_eq!(
    datetime!(2020-01-01 0:00:00 UTC).to_hms_nano(),
    (0, 0, 0, 0)
);
assert_eq!(
    datetime!(2020-01-01 23:59:59.999_999_999 UTC).to_hms_nano(),
    (23, 59, 59, 999_999_999)
);

pub fn hour(self) -> u8

Get the clock hour in the stored offset.

The returned value will always be in the range 0..24.

assert_eq!(datetime!(2019-01-01 0:00 UTC).hour(), 0);
assert_eq!(
    datetime!(2019-01-01 23:59:59 UTC)
        .to_offset(offset!(-2))
        .hour(),
    21,
);

pub fn minute(self) -> u8

Get the minute within the hour in the stored offset.

The returned value will always be in the range 0..60.

assert_eq!(datetime!(2019-01-01 0:00 UTC).minute(), 0);
assert_eq!(
    datetime!(2019-01-01 23:59:59 UTC)
        .to_offset(offset!(+0:30))
        .minute(),
    29,
);

pub fn second(self) -> u8

Get the second within the minute in the stored offset.

The returned value will always be in the range 0..60.

assert_eq!(datetime!(2019-01-01 0:00 UTC).second(), 0);
assert_eq!(
    datetime!(2019-01-01 23:59:59 UTC)
        .to_offset(offset!(+0:00:30))
        .second(),
    29,
);

pub fn millisecond(self) -> u16

Get the milliseconds within the second in the stored offset.

The returned value will always be in the range 0..1_000.

assert_eq!(datetime!(2019-01-01 0:00 UTC).millisecond(), 0);
assert_eq!(datetime!(2019-01-01 23:59:59.999 UTC).millisecond(), 999);

pub fn microsecond(self) -> u32

Get the microseconds within the second in the stored offset.

The returned value will always be in the range 0..1_000_000.

assert_eq!(datetime!(2019-01-01 0:00 UTC).microsecond(), 0);
assert_eq!(
    datetime!(2019-01-01 23:59:59.999_999 UTC).microsecond(),
    999_999,
);

pub fn nanosecond(self) -> u32

Get the nanoseconds within the second in the stored offset.

The returned value will always be in the range 0..1_000_000_000.

assert_eq!(datetime!(2019-01-01 0:00 UTC).nanosecond(), 0);
assert_eq!(
    datetime!(2019-01-01 23:59:59.999_999_999 UTC).nanosecond(),
    999_999_999,
);

pub fn checked_add(self, duration: SignedDuration) -> Option<OffsetDateTime>

Computes self + duration, returning None if an overflow occurred.

let datetime = Date::MIN.midnight().assume_offset(offset!(+10));
assert_eq!(datetime.checked_add((-2).days()), None);

let datetime = Date::MAX.midnight().assume_offset(offset!(+10));
assert_eq!(datetime.checked_add(2.days()), None);

assert_eq!(
    datetime!(2019-11-25 15:30 +10).checked_add(27.hours()),
    Some(datetime!(2019-11-26 18:30 +10))
);

pub fn checked_sub(self, duration: SignedDuration) -> Option<OffsetDateTime>

Computes self - duration, returning None if an overflow occurred.

let datetime = Date::MIN.midnight().assume_offset(offset!(+10));
assert_eq!(datetime.checked_sub(2.days()), None);

let datetime = Date::MAX.midnight().assume_offset(offset!(+10));
assert_eq!(datetime.checked_sub((-2).days()), None);

assert_eq!(
    datetime!(2019-11-25 15:30 +10).checked_sub(27.hours()),
    Some(datetime!(2019-11-24 12:30 +10))
);

pub fn saturating_add(self, duration: SignedDuration) -> OffsetDateTime

Computes self + duration, saturating value on overflow.

assert_eq!(
    datetime!(-9999-01-01 0:00 +10).saturating_add((-2).days()),
    datetime!(-9999-01-01 0:00 +10)
);

assert_eq!(
    datetime!(+9999-12-31 23:59:59.999_999_999 +10).saturating_add(2.days()),
    datetime!(+9999-12-31 23:59:59.999_999_999 +10)
);

assert_eq!(
    datetime!(2019-11-25 15:30 +10).saturating_add(27.hours()),
    datetime!(2019-11-26 18:30 +10)
);

pub fn saturating_sub(self, duration: SignedDuration) -> OffsetDateTime

Computes self - duration, saturating value on overflow.

assert_eq!(
    datetime!(-9999-01-01 0:00 +10).saturating_sub(2.days()),
    datetime!(-9999-01-01 0:00 +10)
);

assert_eq!(
    datetime!(+9999-12-31 23:59:59.999_999_999 +10).saturating_sub((-2).days()),
    datetime!(+9999-12-31 23:59:59.999_999_999 +10)
);

assert_eq!(
    datetime!(2019-11-25 15:30 +10).saturating_sub(27.hours()),
    datetime!(2019-11-24 12:30 +10)
);

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

Replace the time, which is assumed to be in the stored offset. The date and offset components are unchanged.

assert_eq!(
    datetime!(2020-01-01 5:00 UTC).replace_time(time!(12:00)),
    datetime!(2020-01-01 12:00 UTC)
);
assert_eq!(
    datetime!(2020-01-01 12:00 -5).replace_time(time!(7:00)),
    datetime!(2020-01-01 7:00 -5)
);
assert_eq!(
    datetime!(2020-01-01 0:00 +1).replace_time(time!(12:00)),
    datetime!(2020-01-01 12:00 +1)
);

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

Replace the date, which is assumed to be in the stored offset. The time and offset components are unchanged.

assert_eq!(
    datetime!(2020-01-01 12:00 UTC).replace_date(date!(2020-01-30)),
    datetime!(2020-01-30 12:00 UTC)
);
assert_eq!(
    datetime!(2020-01-01 0:00 +1).replace_date(date!(2020-01-30)),
    datetime!(2020-01-30 0:00 +1)
);

pub fn replace_date_time(self, date_time: PlainDateTime) -> OffsetDateTime

Replace the date and time, which are assumed to be in the stored offset. The offset component remains unchanged.

assert_eq!(
    datetime!(2020-01-01 12:00 UTC).replace_date_time(datetime!(2020-01-30 16:00)),
    datetime!(2020-01-30 16:00 UTC)
);
assert_eq!(
    datetime!(2020-01-01 12:00 +1).replace_date_time(datetime!(2020-01-30 0:00)),
    datetime!(2020-01-30 0:00 +1)
);

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

Replace the offset. The date and time components remain unchanged.

assert_eq!(
    datetime!(2020-01-01 0:00 UTC).replace_offset(offset!(-5)),
    datetime!(2020-01-01 0:00 -5)
);

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

Replace the year. The month and day will be unchanged.

assert_eq!(
    datetime!(2022-02-18 12:00 +01).replace_year(2019),
    Ok(datetime!(2019-02-18 12:00 +01))
);
assert!(datetime!(2022-02-18 12:00 +01).replace_year(-1_000_000_000).is_err()); // -1_000_000_000 isn't a valid year
assert!(datetime!(2022-02-18 12:00 +01).replace_year(1_000_000_000).is_err()); // 1_000_000_000 isn't a valid year

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

Replace the month of the year.

assert_eq!(
    datetime!(2022-02-18 12:00 +01).replace_month(Month::January),
    Ok(datetime!(2022-01-18 12:00 +01))
);
assert!(datetime!(2022-01-30 12:00 +01).replace_month(Month::February).is_err()); // 30 isn't a valid day in February

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

Replace the day of the month.

assert_eq!(
    datetime!(2022-02-18 12:00 +01).replace_day(1),
    Ok(datetime!(2022-02-01 12:00 +01))
);
assert!(datetime!(2022-02-18 12:00 +01).replace_day(0).is_err()); // 00 isn't a valid day
assert!(datetime!(2022-02-18 12:00 +01).replace_day(30).is_err()); // 30 isn't a valid day in February

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

Replace the day of the year.

assert_eq!(datetime!(2022-049 12:00 +01).replace_ordinal(1), Ok(datetime!(2022-001 12:00 +01)));
assert!(datetime!(2022-049 12:00 +01).replace_ordinal(0).is_err()); // 0 isn't a valid ordinal
assert!(datetime!(2022-049 12:00 +01).replace_ordinal(366).is_err()); // 2022 isn't a leap year

pub fn truncate_to_day(self) -> OffsetDateTime

Truncate to the start of the day, setting the time to midnight.

assert_eq!(
    datetime!(2022-02-18 15:30:45.123 +01).truncate_to_day(),
    datetime!(2022-02-18 0:00 +01)
);

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

Replace the clock hour.

assert_eq!(
    datetime!(2022-02-18 01:02:03.004_005_006 +01).replace_hour(7),
    Ok(datetime!(2022-02-18 07:02:03.004_005_006 +01))
);
assert!(datetime!(2022-02-18 01:02:03.004_005_006 +01).replace_hour(24).is_err()); // 24 isn't a valid hour

pub fn truncate_to_hour(self) -> OffsetDateTime

Truncate to the hour, setting the minute, second, and subsecond components to zero.

assert_eq!(
    datetime!(2022-02-18 15:30:45.123 +01).truncate_to_hour(),
    datetime!(2022-02-18 15:00 +01)
);

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

Replace the minutes within the hour.

assert_eq!(
    datetime!(2022-02-18 01:02:03.004_005_006 +01).replace_minute(7),
    Ok(datetime!(2022-02-18 01:07:03.004_005_006 +01))
);
assert!(datetime!(2022-02-18 01:02:03.004_005_006 +01).replace_minute(60).is_err()); // 60 isn't a valid minute

pub fn truncate_to_minute(self) -> OffsetDateTime

Truncate to the minute, setting the second and subsecond components to zero.

assert_eq!(
    datetime!(2022-02-18 15:30:45.123 +01).truncate_to_minute(),
    datetime!(2022-02-18 15:30 +01)
);

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

Replace the seconds within the minute.

assert_eq!(
    datetime!(2022-02-18 01:02:03.004_005_006 +01).replace_second(7),
    Ok(datetime!(2022-02-18 01:02:07.004_005_006 +01))
);
assert!(datetime!(2022-02-18 01:02:03.004_005_006 +01).replace_second(60).is_err()); // 60 isn't a valid second

pub fn truncate_to_second(self) -> OffsetDateTime

Truncate to the second, setting the subsecond components to zero.

assert_eq!(
    datetime!(2022-02-18 15:30:45.123 +01).truncate_to_second(),
    datetime!(2022-02-18 15:30:45 +01)
);

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

Replace the milliseconds within the second.

assert_eq!(
    datetime!(2022-02-18 01:02:03.004_005_006 +01).replace_millisecond(7),
    Ok(datetime!(2022-02-18 01:02:03.007 +01))
);
assert!(datetime!(2022-02-18 01:02:03.004_005_006 +01).replace_millisecond(1_000).is_err()); // 1_000 isn't a valid millisecond

pub fn truncate_to_millisecond(self) -> OffsetDateTime

Truncate to the millisecond, setting the microsecond and nanosecond components to zero.

assert_eq!(
    datetime!(2022-02-18 15:30:45.123_456_789 +01).truncate_to_millisecond(),
    datetime!(2022-02-18 15:30:45.123 +01)
);

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

Replace the microseconds within the second.

assert_eq!(
    datetime!(2022-02-18 01:02:03.004_005_006 +01).replace_microsecond(7_008),
    Ok(datetime!(2022-02-18 01:02:03.007_008 +01))
);
assert!(datetime!(2022-02-18 01:02:03.004_005_006 +01).replace_microsecond(1_000_000).is_err()); // 1_000_000 isn't a valid microsecond

pub fn truncate_to_microsecond(self) -> OffsetDateTime

Truncate to the microsecond, setting the nanosecond component to zero.

assert_eq!(
    datetime!(2022-02-18 15:30:45.123_456_789 +01).truncate_to_microsecond(),
    datetime!(2022-02-18 15:30:45.123_456 +01)
);

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

Replace the nanoseconds within the second.

assert_eq!(
    datetime!(2022-02-18 01:02:03.004_005_006 +01).replace_nanosecond(7_008_009),
    Ok(datetime!(2022-02-18 01:02:03.007_008_009 +01))
);
assert!(datetime!(2022-02-18 01:02:03.004_005_006 +01).replace_nanosecond(1_000_000_000).is_err()); // 1_000_000_000 isn't a valid nanosecond

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

Format the OffsetDateTime using the provided format description.

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

Format the OffsetDateTime using the provided format description.

let format = format_description::parse_borrowed::<3>(
    "[year]-[month]-[day] [hour]:[minute]:[second] [offset_hour \
         sign:mandatory]:[offset_minute]:[offset_second]",
)?;
assert_eq!(
    datetime!(2020-01-02 03:04:05 +06:07:08).format(&format)?,
    "2020-01-02 03:04:05 +06:07:08"
);

Trait Implementations

impl Clone for DateTime

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for DateTime

impl Debug for DateTime

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

Formats the value using the given formatter.

impl Deref for DateTime

type Target = OffsetDateTime

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl DerefMut for DateTime

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

impl<'de> Deserialize<'de> for DateTime

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

Lenient (see DateTime::parse_lenient), so no value the contract allows is refused.

impl Display for DateTime

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

The RFC 3339 rendering — the same bytes Serialize writes.

This matters beyond convenience: a multipart/form-data text part and a text/plain body are rendered through Display, so a Display that disagreed with Serialize would put two different encodings of the same value on the wire depending on the body’s media type.

RFC 3339 fixes the year at four digits, so a year outside 0..=9999 — which time can hold but RFC 3339 cannot express — has no rendering here. It falls back to time’s own form rather than failing, because Display failure would panic through to_string() at exactly those two call sites. Serialize still refuses such a value, so it can never reach a JSON body claiming to be RFC 3339.

impl Eq for DateTime

impl From<DateTime> for OffsetDateTime

fn from(value: DateTime) -> Self

Converts to this type from the input type.

impl From<OffsetDateTime> for DateTime

fn from(value: OffsetDateTime) -> Self

Converts to this type from the input type.

impl FromStr for DateTime

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

Strict RFC 3339 (see DateTime::parse_strict).

type Err = ParseError

The associated error which can be returned from parsing.

impl Hash for DateTime

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 DateTime

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.

fn clamp_to<R>(self, range: R) -> Self

where Self: Sized, R: ClampBounds<Self>,

🔬This is a nightly-only experimental API. (clamp_to)

Restrict a value to a certain range.

impl PartialEq for DateTime

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

Equality operator ==.

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

Inequality operator !=.

impl PartialOrd for DateTime

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 DateTime

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

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for DateTime