Struct OffsetDateTime

pub struct OffsetDateTime { /* private fields */ }

A PlainDateTime with a UtcOffset.

Implementations

impl OffsetDateTime

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

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

# use time_macros::{datetime, time};
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)
);

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

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

# use time_macros::{datetime, date};
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)
);

const fn replace_date_time(self, date_time: PlainDateTime) -> Self

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

# use time_macros::datetime;
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)
);

const fn replace_offset(self, offset: UtcOffset) -> Self

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

# use time_macros::{datetime, offset};
assert_eq!(
    datetime!(2020-01-01 0:00 UTC).replace_offset(offset!(-5)),
    datetime!(2020-01-01 0:00 -5)
);

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

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

# use time_macros::datetime;
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

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

Replace the month of the year.

# use time_macros::datetime;
# use time::Month;
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

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

Replace the day of the month.

# use time_macros::datetime;
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

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

Replace the day of the year.

# use time_macros::datetime;
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

const fn truncate_to_day(self) -> Self

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

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

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

Replace the clock hour.

# use time_macros::datetime;
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

const fn truncate_to_hour(self) -> Self

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

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

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

Replace the minutes within the hour.

# use time_macros::datetime;
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

const fn truncate_to_minute(self) -> Self

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

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

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

Replace the seconds within the minute.

# use time_macros::datetime;
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

const fn truncate_to_second(self) -> Self

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

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

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

Replace the milliseconds within the second.

# use time_macros::datetime;
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

const fn truncate_to_millisecond(self) -> Self

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

# use time_macros::datetime;
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)
);

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

Replace the microseconds within the second.

# use time_macros::datetime;
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

const fn truncate_to_microsecond(self) -> Self

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

# use time_macros::datetime;
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)
);

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

Replace the nanoseconds within the second.

# use time_macros::datetime;
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

impl OffsetDateTime

const UNIX_EPOCH: Self = _;

Midnight, 1 January, 1970 (UTC).

# use time::OffsetDateTime;
# use time_macros::datetime;
assert_eq!(OffsetDateTime::UNIX_EPOCH, datetime!(1970-01-01 0:00 UTC));

fn now_utc() -> Self

Create a new OffsetDateTime with the current date and time in UTC.

# use time::OffsetDateTime;
# use time_macros::offset;
assert!(OffsetDateTime::now_utc().year() >= 2019);
assert_eq!(OffsetDateTime::now_utc().offset(), offset!(UTC));

const fn new_in_offset(date: Date, time: Time, offset: UtcOffset) -> Self

Create a new OffsetDateTime with the given Date, Time, and UtcOffset.

# use time::{Date, Month, OffsetDateTime, Time, UtcOffset};
# use time_macros::datetime;
let dt = OffsetDateTime::new_in_offset(
    Date::from_calendar_date(2024, Month::January, 1)?,
    Time::from_hms_nano(12, 59, 59, 500_000_000)?,
    UtcOffset::from_hms(-5, 0, 0)?,
);
assert_eq!(dt, datetime!(2024-01-01 12:59:59.5 -5));
# Ok::<_, time::error::Error>(())

const fn new_utc(date: Date, time: Time) -> Self

Create a new OffsetDateTime with the given Date and Time in the UTC timezone.

# use time::{Date, Month, OffsetDateTime, Time};
# use time_macros::datetime;
let dt = OffsetDateTime::new_utc(
    Date::from_calendar_date(2024, Month::January, 1)?,
    Time::from_hms_nano(12, 59, 59, 500_000_000)?,
);
assert_eq!(dt, datetime!(2024-01-01 12:59:59.5 UTC));
# Ok::<_, time::error::Error>(())

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

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

# use time_macros::{datetime, offset};
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.

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

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

# use time::PlainDateTime;
# use time_macros::{datetime, offset};
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,
);

const fn to_utc(self) -> UtcDateTime

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

# use time_macros::datetime;
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.

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

# use time_macros::datetime;
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,
);

const fn from_unix_timestamp(timestamp: i64) -> Result<Self, ComponentRange>

Create an OffsetDateTime from the provided Unix timestamp. Calling .offset() on the resulting value is guaranteed to return UTC.

# use time::OffsetDateTime;
# use time_macros::datetime;
assert_eq!(
    OffsetDateTime::from_unix_timestamp(0),
    Ok(OffsetDateTime::UNIX_EPOCH),
);
assert_eq!(
    OffsetDateTime::from_unix_timestamp(1_546_300_800),
    Ok(datetime!(2019-01-01 0:00 UTC)),
);

If you have a timestamp-nanosecond pair, you can use something along the lines of the following:

# use time::{SignedDuration, OffsetDateTime, ext::NumericalDuration};
let (timestamp, nanos) = (1, 500_000_000);
assert_eq!(
    OffsetDateTime::from_unix_timestamp(timestamp)? + SignedDuration::nanoseconds(nanos),
    OffsetDateTime::UNIX_EPOCH + 1.5.seconds()
);
# Ok::<_, time::Error>(())

const fn from_unix_timestamp_nanos(timestamp: i128) -> Result<Self, ComponentRange>

Construct an OffsetDateTime from the provided Unix timestamp (in nanoseconds). Calling .offset() on the resulting value is guaranteed to return UTC.

# use time::OffsetDateTime;
# use time_macros::datetime;
assert_eq!(
    OffsetDateTime::from_unix_timestamp_nanos(0),
    Ok(OffsetDateTime::UNIX_EPOCH),
);
assert_eq!(
    OffsetDateTime::from_unix_timestamp_nanos(1_546_300_800_000_000_000),
    Ok(datetime!(2019-01-01 0:00 UTC)),
);

const fn offset(self) -> UtcOffset

Get the UtcOffset.

# use time_macros::{datetime, offset};
assert_eq!(datetime!(2019-01-01 0:00 UTC).offset(), offset!(UTC));
assert_eq!(datetime!(2019-01-01 0:00 +1).offset(), offset!(+1));

const fn unix_timestamp(self) -> i64

Get the Unix timestamp.

# use time_macros::datetime;
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);

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

const fn date(self) -> Date

Get the Date in the stored offset.

# use time_macros::{date, datetime, 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),
);

const fn time(self) -> Time

Get the Time in the stored offset.

# use time_macros::{datetime, offset, time};
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)
);

const fn year(self) -> i32

Get the year of the date in the stored offset.

# use time_macros::{datetime, 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);

const fn month(self) -> Month

Get the month of the date in the stored offset.

# use time::Month;
# use time_macros::{datetime, 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,
);

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

# use time_macros::{datetime, offset};
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,
);

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

# use time_macros::{datetime, offset};
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,
);

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

# use time_macros::datetime;
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);

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

# use time_macros::datetime;
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);

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

# use time_macros::datetime;
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);

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

Get the year, month, and day.

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

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

Get the year and ordinal day number.

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

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

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

# use time::Weekday::*;
# use time_macros::datetime;
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)
);

const fn weekday(self) -> Weekday

Get the weekday of the date in the stored offset.

# use time::Weekday::*;
# use time_macros::datetime;
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);

const fn to_julian_day(self) -> i32

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

# use time_macros::datetime;
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);

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

Get the clock hour, minute, and second.

# use time_macros::datetime;
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));

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

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

# use time_macros::datetime;
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)
);

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

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

# use time_macros::datetime;
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)
);

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

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

# use time_macros::datetime;
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)
);

const fn hour(self) -> u8

Get the clock hour in the stored offset.

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

# use time_macros::{datetime, offset};
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,
);

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

# use time_macros::{datetime, offset};
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,
);

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

# use time_macros::{datetime, offset};
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,
);

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

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

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

# use time_macros::datetime;
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,
);

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

# use time_macros::datetime;
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,
);

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

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

# use time::{Date, ext::NumericalDuration};
# use time_macros::{datetime, offset};
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))
);

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

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

# use time::{Date, ext::NumericalDuration};
# use time_macros::{datetime, offset};
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))
);

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

Computes self + duration, saturating value on overflow.

# use time::ext::NumericalDuration;
# use time_macros::datetime;
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)
);

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

Computes self - duration, saturating value on overflow.

# use time::ext::NumericalDuration;
# use time_macros::datetime;
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)
);

Trait Implementations

impl Add<Duration> for OffsetDateTime

type Output = OffsetDateTime;
fn add(self, duration: StdDuration) -> Self::Output

Panics

This may panic if an overflow occurs.

impl Add<SignedDuration> for OffsetDateTime

type Output = OffsetDateTime;
fn add(self, duration: SignedDuration) -> Self::Output

Panics

This may panic if an overflow occurs.

impl AddAssign<Duration> for OffsetDateTime

fn add_assign(&mut self, rhs: StdDuration)

Panics

This may panic if an overflow occurs.

impl AddAssign<SignedDuration> for OffsetDateTime

fn add_assign(&mut self, rhs: SignedDuration)

Panics

This may panic if an overflow occurs.

impl Clone for OffsetDateTime

fn clone(&self) -> OffsetDateTime

impl Copy for OffsetDateTime

impl Debug for OffsetDateTime

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

impl Display for OffsetDateTime

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

impl Eq for OffsetDateTime

impl From<SystemTime> for OffsetDateTime

fn from(system_time: SystemTime) -> Self

impl From<Timestamp> for OffsetDateTime

fn from(timestamp: Timestamp) -> Self

impl From<UtcDateTime> for OffsetDateTime

fn from(datetime: UtcDateTime) -> Self

Panics

This may panic if an overflow occurs.

impl Hash for OffsetDateTime

fn hash<H>(&self, state: &mut H)
where
    H: Hasher,

impl Ord for OffsetDateTime

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

impl PartialEq for OffsetDateTime

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

impl PartialEq<SystemTime> for OffsetDateTime

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

impl PartialEq<Timestamp> for OffsetDateTime

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

impl PartialEq<UtcDateTime> for OffsetDateTime

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

impl PartialOrd for OffsetDateTime

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

impl PartialOrd<SystemTime> for OffsetDateTime

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

impl PartialOrd<Timestamp> for OffsetDateTime

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

impl PartialOrd<UtcDateTime> for OffsetDateTime

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

impl SmartDisplay for OffsetDateTime

type Metadata = ();
fn metadata(&self, f: FormatterOptions) -> Metadata<'_, Self>
fn fmt(&self, f: &mut Formatter<'_>) -> Result

impl Sub for OffsetDateTime

type Output = SignedDuration;
fn sub(self, rhs: Self) -> Self::Output

impl Sub<Duration> for OffsetDateTime

type Output = OffsetDateTime;
fn sub(self, duration: StdDuration) -> Self::Output

Panics

This may panic if an overflow occurs.

impl Sub<SignedDuration> for OffsetDateTime

type Output = OffsetDateTime;
fn sub(self, rhs: SignedDuration) -> Self::Output

Panics

This may panic if an overflow occurs.

impl Sub<SystemTime> for OffsetDateTime

type Output = SignedDuration;
fn sub(self, rhs: SystemTime) -> Self::Output

Panics

This may panic if an overflow occurs.

impl Sub<Timestamp> for OffsetDateTime

type Output = SignedDuration;
fn sub(self, rhs: Timestamp) -> Self::Output

impl Sub<UtcDateTime> for OffsetDateTime

type Output = SignedDuration;
fn sub(self, rhs: UtcDateTime) -> Self::Output

Panics

This may panic if an overflow occurs.

impl SubAssign<Duration> for OffsetDateTime

fn sub_assign(&mut self, rhs: StdDuration)

Panics

This may panic if an overflow occurs.

impl SubAssign<SignedDuration> for OffsetDateTime

fn sub_assign(&mut self, rhs: SignedDuration)

Panics

This may panic if an overflow occurs.

Auto Trait Implementations

impl Freeze for OffsetDateTime

impl RefUnwindSafe for OffsetDateTime

impl Send for OffsetDateTime

impl Sync for OffsetDateTime

impl Unpin for OffsetDateTime

impl UnsafeUnpin for OffsetDateTime

impl UnwindSafe for OffsetDateTime

Blanket Implementations

impl<T> Any for OffsetDateTime where T: 'static + ?Sized,

fn type_id(&self) -> TypeId

impl<T> Borrow<T> for OffsetDateTime where T: ?Sized,

fn borrow(&self) -> &T

impl<T> BorrowMut<T> for OffsetDateTime where T: ?Sized,

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

impl<T> CloneToUninit for OffsetDateTime where T: Clone,

unsafe fn clone_to_uninit(&self, dest: *mut u8)

impl<T> From<T> for OffsetDateTime

fn from(t: T) -> T

Returns the argument unchanged.

impl<T> ToOwned for OffsetDateTime where T: Clone,

type Owned = T;
fn to_owned(&self) -> T
fn clone_into(&self, target: &mut T)

impl<T> ToString for OffsetDateTime where T: Display + ?Sized,

fn to_string(&self) -> String

impl<T, U> Into<U> for OffsetDateTime where U: From<T>,

fn into(self) -> U

Calls U::from(self).

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

impl<T, U> TryFrom<U> for OffsetDateTime where U: Into<T>,

type Error = never;
fn try_from(value: U) -> Result<T, never>

impl<T, U> TryInto<U> for OffsetDateTime where U: TryFrom<T>,

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