Struct actix_web::cookie::time::OffsetDateTime
source · pub struct OffsetDateTime { /* private fields */ }
Expand description
A PrimitiveDateTime
with a UtcOffset
.
All comparisons are performed using the UTC time.
Implementations§
source§impl OffsetDateTime
impl OffsetDateTime
sourcepub const UNIX_EPOCH: OffsetDateTime = _
pub const UNIX_EPOCH: OffsetDateTime = _
Midnight, 1 January, 1970 (UTC).
assert_eq!(OffsetDateTime::UNIX_EPOCH, datetime!(1970-01-01 0:00 UTC),);
sourcepub fn now_utc() -> OffsetDateTime
pub fn now_utc() -> OffsetDateTime
Create a new OffsetDateTime
with the current date and time in UTC.
assert!(OffsetDateTime::now_utc().year() >= 2019);
assert_eq!(OffsetDateTime::now_utc().offset(), offset!(UTC));
sourcepub const fn new_in_offset(
date: Date,
time: Time,
offset: UtcOffset,
) -> OffsetDateTime
pub const fn new_in_offset( date: Date, time: Time, offset: UtcOffset, ) -> OffsetDateTime
sourcepub const fn new_utc(date: Date, time: Time) -> OffsetDateTime
pub const fn new_utc(date: Date, time: Time) -> OffsetDateTime
sourcepub const fn to_offset(self, offset: UtcOffset) -> OffsetDateTime
pub const 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.
sourcepub const fn checked_to_offset(
self,
offset: UtcOffset,
) -> Option<OffsetDateTime>
pub const 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!(
PrimitiveDateTime::MAX
.assume_utc()
.checked_to_offset(offset!(+1)),
None,
);
sourcepub const fn from_unix_timestamp(
timestamp: i64,
) -> Result<OffsetDateTime, ComponentRange>
pub const fn from_unix_timestamp( timestamp: i64, ) -> Result<OffsetDateTime, ComponentRange>
Create an OffsetDateTime
from the provided Unix timestamp. Calling .offset()
on the
resulting value is guaranteed to return UTC.
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:
let (timestamp, nanos) = (1, 500_000_000);
assert_eq!(
OffsetDateTime::from_unix_timestamp(timestamp)? + Duration::nanoseconds(nanos),
OffsetDateTime::UNIX_EPOCH + 1.5.seconds()
);
sourcepub const fn from_unix_timestamp_nanos(
timestamp: i128,
) -> Result<OffsetDateTime, ComponentRange>
pub const fn from_unix_timestamp_nanos( timestamp: i128, ) -> Result<OffsetDateTime, ComponentRange>
Construct an OffsetDateTime
from the provided Unix timestamp (in nanoseconds). Calling
.offset()
on the resulting value is guaranteed to return UTC.
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)),
);
sourcepub const fn offset(self) -> UtcOffset
pub const 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));
sourcepub const fn unix_timestamp(self) -> i64
pub const 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);
sourcepub const fn unix_timestamp_nanos(self) -> i128
pub 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,
);
sourcepub const fn date(self) -> Date
pub const 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),
);
sourcepub const fn time(self) -> Time
pub const 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)
);
sourcepub const fn year(self) -> i32
pub const 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);
sourcepub const fn month(self) -> Month
pub const 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,
);
sourcepub const fn day(self) -> u8
pub 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
.
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,
);
sourcepub const fn ordinal(self) -> u16
pub 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
.
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,
);
sourcepub const fn iso_week(self) -> u8
pub 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
.
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);
sourcepub const fn sunday_based_week(self) -> u8
pub 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
.
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);
sourcepub const fn monday_based_week(self) -> u8
pub 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
.
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);
sourcepub const fn to_calendar_date(self) -> (i32, Month, u8)
pub const 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)
);
sourcepub const fn to_ordinal_date(self) -> (i32, u16)
pub const 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)
);
sourcepub const fn to_iso_week_date(self) -> (i32, u8, Weekday)
pub const 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)
);
sourcepub const fn weekday(self) -> Weekday
pub const 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);
sourcepub const fn to_julian_day(self) -> i32
pub const fn to_julian_day(self) -> i32
Get the Julian day for the date. The time is not taken into account for this calculation.
The algorithm to perform this conversion is derived from one provided by Peter Baum; it is freely available here.
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);
sourcepub const fn to_hms(self) -> (u8, u8, u8)
pub const 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));
sourcepub const fn to_hms_milli(self) -> (u8, u8, u8, u16)
pub const 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)
);
sourcepub const fn to_hms_micro(self) -> (u8, u8, u8, u32)
pub const 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)
);
sourcepub const fn to_hms_nano(self) -> (u8, u8, u8, u32)
pub const 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)
);
sourcepub const fn hour(self) -> u8
pub const 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,
);
sourcepub const fn minute(self) -> u8
pub 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
.
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,
);
sourcepub const fn second(self) -> u8
pub 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
.
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,
);
sourcepub const fn millisecond(self) -> u16
pub 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
.
assert_eq!(datetime!(2019-01-01 0:00 UTC).millisecond(), 0);
assert_eq!(datetime!(2019-01-01 23:59:59.999 UTC).millisecond(), 999);
sourcepub const fn microsecond(self) -> u32
pub 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
.
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,
);
sourcepub const fn nanosecond(self) -> u32
pub 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
.
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,
);
sourcepub const fn checked_add(self, duration: Duration) -> Option<OffsetDateTime>
pub const fn checked_add(self, duration: Duration) -> 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))
);
sourcepub const fn checked_sub(self, duration: Duration) -> Option<OffsetDateTime>
pub const fn checked_sub(self, duration: Duration) -> 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))
);
sourcepub const fn saturating_add(self, duration: Duration) -> OffsetDateTime
pub const fn saturating_add(self, duration: Duration) -> 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)
);
sourcepub const fn saturating_sub(self, duration: Duration) -> OffsetDateTime
pub const fn saturating_sub(self, duration: Duration) -> 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)
);
source§impl OffsetDateTime
impl OffsetDateTime
Methods that replace part of the OffsetDateTime
.
sourcepub const fn replace_time(self, time: Time) -> OffsetDateTime
pub const 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)
);
sourcepub const fn replace_date(self, date: Date) -> OffsetDateTime
pub const 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)
);
sourcepub const fn replace_date_time(
self,
date_time: PrimitiveDateTime,
) -> OffsetDateTime
pub const fn replace_date_time( self, date_time: PrimitiveDateTime, ) -> 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)
);
sourcepub const fn replace_offset(self, offset: UtcOffset) -> OffsetDateTime
pub const 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)
);
sourcepub const fn replace_year(
self,
year: i32,
) -> Result<OffsetDateTime, ComponentRange>
pub const 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
sourcepub const fn replace_month(
self,
month: Month,
) -> Result<OffsetDateTime, ComponentRange>
pub const 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
sourcepub const fn replace_day(
self,
day: u8,
) -> Result<OffsetDateTime, ComponentRange>
pub const 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
sourcepub const fn replace_ordinal(
self,
ordinal: u16,
) -> Result<OffsetDateTime, ComponentRange>
pub const 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
sourcepub const fn replace_hour(
self,
hour: u8,
) -> Result<OffsetDateTime, ComponentRange>
pub const 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
sourcepub const fn replace_minute(
self,
minute: u8,
) -> Result<OffsetDateTime, ComponentRange>
pub const 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
sourcepub const fn replace_second(
self,
second: u8,
) -> Result<OffsetDateTime, ComponentRange>
pub const 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
sourcepub const fn replace_millisecond(
self,
millisecond: u16,
) -> Result<OffsetDateTime, ComponentRange>
pub const 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
sourcepub const fn replace_microsecond(
self,
microsecond: u32,
) -> Result<OffsetDateTime, ComponentRange>
pub const 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
sourcepub const fn replace_nanosecond(
self,
nanosecond: u32,
) -> Result<OffsetDateTime, ComponentRange>
pub const 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
source§impl OffsetDateTime
impl OffsetDateTime
sourcepub fn format_into(
self,
output: &mut impl Write,
format: &(impl Formattable + ?Sized),
) -> Result<usize, Format>
pub fn format_into( self, output: &mut impl Write, format: &(impl Formattable + ?Sized), ) -> Result<usize, Format>
Format the OffsetDateTime
using the provided format
description.
sourcepub fn format(
self,
format: &(impl Formattable + ?Sized),
) -> Result<String, Format>
pub fn format( self, format: &(impl Formattable + ?Sized), ) -> Result<String, Format>
Format the OffsetDateTime
using the provided format
description.
let format = format_description::parse(
"[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"
);
source§impl OffsetDateTime
impl OffsetDateTime
sourcepub fn parse(
input: &str,
description: &(impl Parsable + ?Sized),
) -> Result<OffsetDateTime, Parse>
pub fn parse( input: &str, description: &(impl Parsable + ?Sized), ) -> Result<OffsetDateTime, Parse>
Parse an OffsetDateTime
from the input using the provided format
description.
let format = format_description!(
"[year]-[month]-[day] [hour]:[minute]:[second] [offset_hour \
sign:mandatory]:[offset_minute]:[offset_second]"
);
assert_eq!(
OffsetDateTime::parse("2020-01-02 03:04:05 +06:07:08", &format)?,
datetime!(2020-01-02 03:04:05 +06:07:08)
);
Trait Implementations§
source§impl Add<Duration> for OffsetDateTime
impl Add<Duration> for OffsetDateTime
source§impl Add<Duration> for OffsetDateTime
impl Add<Duration> for OffsetDateTime
source§impl AddAssign<Duration> for OffsetDateTime
impl AddAssign<Duration> for OffsetDateTime
source§fn add_assign(&mut self, rhs: Duration)
fn add_assign(&mut self, rhs: Duration)
§Panics
This may panic if an overflow occurs.
source§impl AddAssign<Duration> for OffsetDateTime
impl AddAssign<Duration> for OffsetDateTime
source§fn add_assign(&mut self, rhs: Duration)
fn add_assign(&mut self, rhs: Duration)
§Panics
This may panic if an overflow occurs.
source§impl Clone for OffsetDateTime
impl Clone for OffsetDateTime
source§fn clone(&self) -> OffsetDateTime
fn clone(&self) -> OffsetDateTime
1.0.0 · source§fn clone_from(&mut self, source: &Self)
fn clone_from(&mut self, source: &Self)
source
. Read moresource§impl Debug for OffsetDateTime
impl Debug for OffsetDateTime
source§impl Display for OffsetDateTime
impl Display for OffsetDateTime
source§impl From<SystemTime> for OffsetDateTime
impl From<SystemTime> for OffsetDateTime
source§fn from(system_time: SystemTime) -> OffsetDateTime
fn from(system_time: SystemTime) -> OffsetDateTime
source§impl Hash for OffsetDateTime
impl Hash for OffsetDateTime
source§impl Ord for OffsetDateTime
impl Ord for OffsetDateTime
source§fn cmp(&self, other: &OffsetDateTime) -> Ordering
fn cmp(&self, other: &OffsetDateTime) -> Ordering
1.21.0 · source§fn max(self, other: Self) -> Selfwhere
Self: Sized,
fn max(self, other: Self) -> Selfwhere
Self: Sized,
source§impl PartialEq<SystemTime> for OffsetDateTime
impl PartialEq<SystemTime> for OffsetDateTime
source§fn eq(&self, rhs: &SystemTime) -> bool
fn eq(&self, rhs: &SystemTime) -> bool
self
and other
values to be equal, and is used
by ==
.source§impl PartialEq for OffsetDateTime
impl PartialEq for OffsetDateTime
source§fn eq(&self, other: &OffsetDateTime) -> bool
fn eq(&self, other: &OffsetDateTime) -> bool
self
and other
values to be equal, and is used
by ==
.source§impl PartialOrd<SystemTime> for OffsetDateTime
impl PartialOrd<SystemTime> for OffsetDateTime
source§fn partial_cmp(&self, other: &SystemTime) -> Option<Ordering>
fn partial_cmp(&self, other: &SystemTime) -> Option<Ordering>
1.0.0 · source§fn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
self
and other
) and is used by the <=
operator. Read moresource§impl PartialOrd for OffsetDateTime
impl PartialOrd for OffsetDateTime
source§fn partial_cmp(&self, other: &OffsetDateTime) -> Option<Ordering>
fn partial_cmp(&self, other: &OffsetDateTime) -> Option<Ordering>
1.0.0 · source§fn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
self
and other
) and is used by the <=
operator. Read moresource§impl SmartDisplay for OffsetDateTime
impl SmartDisplay for OffsetDateTime
source§fn metadata(&self, _: FormatterOptions) -> Metadata<'_, OffsetDateTime>
fn metadata(&self, _: FormatterOptions) -> Metadata<'_, OffsetDateTime>
source§fn fmt_with_metadata(
&self,
f: &mut Formatter<'_>,
metadata: Metadata<'_, OffsetDateTime>,
) -> Result<(), Error>
fn fmt_with_metadata( &self, f: &mut Formatter<'_>, metadata: Metadata<'_, OffsetDateTime>, ) -> Result<(), Error>
source§impl Sub<Duration> for OffsetDateTime
impl Sub<Duration> for OffsetDateTime
source§impl Sub<Duration> for OffsetDateTime
impl Sub<Duration> for OffsetDateTime
source§impl Sub<SystemTime> for OffsetDateTime
impl Sub<SystemTime> for OffsetDateTime
source§fn sub(self, rhs: SystemTime) -> <OffsetDateTime as Sub<SystemTime>>::Output
fn sub(self, rhs: SystemTime) -> <OffsetDateTime as Sub<SystemTime>>::Output
§Panics
This may panic if an overflow occurs.
source§impl Sub for OffsetDateTime
impl Sub for OffsetDateTime
source§impl SubAssign<Duration> for OffsetDateTime
impl SubAssign<Duration> for OffsetDateTime
source§fn sub_assign(&mut self, rhs: Duration)
fn sub_assign(&mut self, rhs: Duration)
§Panics
This may panic if an overflow occurs.
source§impl SubAssign<Duration> for OffsetDateTime
impl SubAssign<Duration> for OffsetDateTime
source§fn sub_assign(&mut self, rhs: Duration)
fn sub_assign(&mut self, rhs: Duration)
§Panics
This may panic if an overflow occurs.
source§impl TryFrom<Parsed> for OffsetDateTime
impl TryFrom<Parsed> for OffsetDateTime
§type Error = TryFromParsed
type Error = TryFromParsed
source§fn try_from(
parsed: Parsed,
) -> Result<OffsetDateTime, <OffsetDateTime as TryFrom<Parsed>>::Error>
fn try_from( parsed: Parsed, ) -> Result<OffsetDateTime, <OffsetDateTime as TryFrom<Parsed>>::Error>
impl Copy for OffsetDateTime
impl Eq for OffsetDateTime
Auto Trait Implementations§
impl Freeze for OffsetDateTime
impl RefUnwindSafe for OffsetDateTime
impl Send for OffsetDateTime
impl Sync for OffsetDateTime
impl Unpin for OffsetDateTime
impl UnwindSafe for OffsetDateTime
Blanket Implementations§
source§impl<T> BorrowMut<T> for Twhere
T: ?Sized,
impl<T> BorrowMut<T> for Twhere
T: ?Sized,
source§fn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
source§impl<T> CloneToUninit for Twhere
T: Copy,
impl<T> CloneToUninit for Twhere
T: Copy,
source§unsafe fn clone_to_uninit(&self, dst: *mut T)
unsafe fn clone_to_uninit(&self, dst: *mut T)
clone_to_uninit
)source§impl<T> CloneToUninit for Twhere
T: Clone,
impl<T> CloneToUninit for Twhere
T: Clone,
source§default unsafe fn clone_to_uninit(&self, dst: *mut T)
default unsafe fn clone_to_uninit(&self, dst: *mut T)
clone_to_uninit
)source§impl<Q, K> Comparable<K> for Q
impl<Q, K> Comparable<K> for Q
source§impl<Q, K> Equivalent<K> for Q
impl<Q, K> Equivalent<K> for Q
source§impl<Q, K> Equivalent<K> for Q
impl<Q, K> Equivalent<K> for Q
source§fn equivalent(&self, key: &K) -> bool
fn equivalent(&self, key: &K) -> bool
key
and return true
if they are equal.