impl OffsetDateTime

const fn replace_time(self: 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: 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: Self, date_time: PrimitiveDateTime) -> 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: 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: 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: 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: 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: 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) -> 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: 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) -> 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: 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) -> 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: 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) -> 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: 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) -> 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: 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) -> 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: 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

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: 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: 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::PrimitiveDateTime;
# use time_macros::{datetime, offset};
assert_eq!(
    datetime!(2000-01-01 0:00 UTC)
        .checked_to_offset(offset!(-1))
        .unwrap()
        .year(),
    1999,
);
assert_eq!(
    PrimitiveDateTime::MAX
        .assume_utc()
        .checked_to_offset(offset!(+1)),
    None,
);

const fn to_utc(self: 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: 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::{Duration, OffsetDateTime, ext::NumericalDuration};
let (timestamp, nanos) = (1, 500_000_000);
assert_eq!(
    OffsetDateTime::from_unix_timestamp(timestamp)? + Duration::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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: Self, duration: Duration) -> 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: Self, duration: Duration) -> 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: Self, duration: Duration) -> 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: Self, duration: Duration) -> 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)
);

impl Add for OffsetDateTime

fn add(self: Self, duration: StdDuration) -> <Self as >::Output

Panics

This may panic if an overflow occurs.

impl Add for OffsetDateTime

fn add(self: Self, duration: Duration) -> <Self as >::Output

Panics

This may panic if an overflow occurs.

impl AddAssign for OffsetDateTime

fn add_assign(self: &mut Self, rhs: StdDuration)

Panics

This may panic if an overflow occurs.

impl AddAssign for OffsetDateTime

fn add_assign(self: &mut Self, rhs: Duration)

Panics

This may panic if an overflow occurs.

impl Clone for OffsetDateTime

fn clone(self: &Self) -> OffsetDateTime

impl Copy for OffsetDateTime

impl Debug for OffsetDateTime

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

impl Display for OffsetDateTime

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

impl Eq for OffsetDateTime

impl Freeze for OffsetDateTime

impl From for OffsetDateTime

fn from(system_time: SystemTime) -> Self

impl From for OffsetDateTime

fn from(datetime: UtcDateTime) -> Self

Panics

This may panic if an overflow occurs.

impl Hash for OffsetDateTime

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

impl Ord for OffsetDateTime

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

impl PartialEq for OffsetDateTime

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

impl PartialEq for OffsetDateTime

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

impl PartialEq for OffsetDateTime

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

impl PartialOrd for OffsetDateTime

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

impl PartialOrd for OffsetDateTime

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

impl PartialOrd for OffsetDateTime

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

impl RefUnwindSafe for OffsetDateTime

impl Send for OffsetDateTime

impl SmartDisplay for OffsetDateTime

fn metadata(self: &Self, _: FormatterOptions) -> Metadata<'_, Self>

fn fmt_with_metadata(self: &Self, f: &mut Formatter<'_>, metadata: Metadata<'_, Self>) -> Result

impl Sub for OffsetDateTime

fn sub(self: Self, duration: StdDuration) -> <Self as >::Output

Panics

This may panic if an overflow occurs.

impl Sub for OffsetDateTime

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

Panics

This may panic if an overflow occurs.

impl Sub for OffsetDateTime

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

Panics

This may panic if an overflow occurs.

impl Sub for OffsetDateTime

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

Panics

This may panic if an overflow occurs.

impl Sub for OffsetDateTime

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

Panics

This may panic if an overflow occurs.

impl SubAssign for OffsetDateTime

fn sub_assign(self: &mut Self, rhs: StdDuration)

Panics

This may panic if an overflow occurs.

impl SubAssign for OffsetDateTime

fn sub_assign(self: &mut Self, rhs: Duration)

Panics

This may panic if an overflow occurs.

impl Sync for OffsetDateTime

impl Unpin for OffsetDateTime

impl UnsafeUnpin for OffsetDateTime

impl UnwindSafe for OffsetDateTime

impl<T> Any for OffsetDateTime

fn type_id(self: &Self) -> TypeId

impl<T> Borrow for OffsetDateTime

fn borrow(self: &Self) -> &T

impl<T> BorrowMut for OffsetDateTime

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

impl<T> CloneToUninit for OffsetDateTime

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

impl<T> From for OffsetDateTime

fn from(t: T) -> T

Returns the argument unchanged.

impl<T> ToOwned for OffsetDateTime

fn to_owned(self: &Self) -> T

fn clone_into(self: &Self, target: &mut T)

impl<T> ToString for OffsetDateTime

fn to_string(self: &Self) -> String

impl<T, U> Into for OffsetDateTime

fn into(self: 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 for OffsetDateTime

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

impl<T, U> TryInto for OffsetDateTime

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