Struct kumo_chrono_helper::DateTime
source · pub struct DateTime<Tz>where
Tz: TimeZone,{ /* private fields */ }
Expand description
ISO 8601 combined date and time with time zone.
There are some constructors implemented here (the from_*
methods), but
the general-purpose constructors are all via the methods on the
TimeZone
implementations.
Implementations§
source§impl<Tz> DateTime<Tz>where
Tz: TimeZone,
impl<Tz> DateTime<Tz>where
Tz: TimeZone,
sourcepub const fn from_naive_utc_and_offset(
datetime: NaiveDateTime,
offset: <Tz as TimeZone>::Offset,
) -> DateTime<Tz>
pub const fn from_naive_utc_and_offset( datetime: NaiveDateTime, offset: <Tz as TimeZone>::Offset, ) -> DateTime<Tz>
Makes a new DateTime
from its components: a NaiveDateTime
in UTC and an Offset
.
This is a low-level method, intended for use cases such as deserializing a DateTime
or
passing it through FFI.
For regular use you will probably want to use a method such as
TimeZone::from_local_datetime
or NaiveDateTime::and_local_timezone
instead.
§Example
use chrono::{DateTime, Local};
let dt = Local::now();
// Get components
let naive_utc = dt.naive_utc();
let offset = dt.offset().clone();
// Serialize, pass through FFI... and recreate the `DateTime`:
let dt_new = DateTime::<Local>::from_naive_utc_and_offset(naive_utc, offset);
assert_eq!(dt, dt_new);
sourcepub fn from_utc(
datetime: NaiveDateTime,
offset: <Tz as TimeZone>::Offset,
) -> DateTime<Tz>
👎Deprecated since 0.4.27: Use TimeZone::from_utc_datetime() or DateTime::from_naive_utc_and_offset instead
pub fn from_utc( datetime: NaiveDateTime, offset: <Tz as TimeZone>::Offset, ) -> DateTime<Tz>
Makes a new DateTime
from its components: a NaiveDateTime
in UTC and an Offset
.
sourcepub fn from_local(
datetime: NaiveDateTime,
offset: <Tz as TimeZone>::Offset,
) -> DateTime<Tz>
👎Deprecated since 0.4.27: Use TimeZone::from_local_datetime() or NaiveDateTime::and_local_timezone instead
pub fn from_local( datetime: NaiveDateTime, offset: <Tz as TimeZone>::Offset, ) -> DateTime<Tz>
Makes a new DateTime
from a NaiveDateTime
in local time and an Offset
.
§Panics
Panics if the local datetime can’t be converted to UTC because it would be out of range.
This can happen if datetime
is near the end of the representable range of NaiveDateTime
,
and the offset from UTC pushes it beyond that.
sourcepub fn date(&self) -> Date<Tz>
👎Deprecated since 0.4.23: Use date_naive()
instead
pub fn date(&self) -> Date<Tz>
date_naive()
insteadRetrieves the date component with an associated timezone.
Unless you are immediately planning on turning this into a DateTime
with the same timezone you should use the date_naive
method.
NaiveDate
is a more well-defined type, and has more traits implemented on it,
so should be preferred to Date
any time you truly want to operate on dates.
§Panics
DateTime
internally stores the date and time in UTC with a NaiveDateTime
. This
method will panic if the offset from UTC would push the local date outside of the
representable range of a Date
.
sourcepub fn date_naive(&self) -> NaiveDate
pub fn date_naive(&self) -> NaiveDate
Retrieves the date component.
§Panics
DateTime
internally stores the date and time in UTC with a NaiveDateTime
. This
method will panic if the offset from UTC would push the local date outside of the
representable range of a NaiveDate
.
§Example
use chrono::prelude::*;
let date: DateTime<Utc> = Utc.with_ymd_and_hms(2020, 1, 1, 0, 0, 0).unwrap();
let other: DateTime<FixedOffset> =
FixedOffset::east_opt(23).unwrap().with_ymd_and_hms(2020, 1, 1, 0, 0, 0).unwrap();
assert_eq!(date.date_naive(), other.date_naive());
sourcepub const fn timestamp(&self) -> i64
pub const fn timestamp(&self) -> i64
Returns the number of non-leap seconds since January 1, 1970 0:00:00 UTC (aka “UNIX timestamp”).
The reverse operation of creating a DateTime
from a timestamp can be performed
using from_timestamp
or TimeZone::timestamp_opt
.
use chrono::{DateTime, TimeZone, Utc};
let dt: DateTime<Utc> = Utc.with_ymd_and_hms(2015, 5, 15, 0, 0, 0).unwrap();
assert_eq!(dt.timestamp(), 1431648000);
assert_eq!(DateTime::from_timestamp(dt.timestamp(), dt.timestamp_subsec_nanos()).unwrap(), dt);
sourcepub const fn timestamp_millis(&self) -> i64
pub const fn timestamp_millis(&self) -> i64
Returns the number of non-leap-milliseconds since January 1, 1970 UTC.
§Example
use chrono::{NaiveDate, Utc};
let dt = NaiveDate::from_ymd_opt(1970, 1, 1)
.unwrap()
.and_hms_milli_opt(0, 0, 1, 444)
.unwrap()
.and_local_timezone(Utc)
.unwrap();
assert_eq!(dt.timestamp_millis(), 1_444);
let dt = NaiveDate::from_ymd_opt(2001, 9, 9)
.unwrap()
.and_hms_milli_opt(1, 46, 40, 555)
.unwrap()
.and_local_timezone(Utc)
.unwrap();
assert_eq!(dt.timestamp_millis(), 1_000_000_000_555);
sourcepub const fn timestamp_micros(&self) -> i64
pub const fn timestamp_micros(&self) -> i64
Returns the number of non-leap-microseconds since January 1, 1970 UTC.
§Example
use chrono::{NaiveDate, Utc};
let dt = NaiveDate::from_ymd_opt(1970, 1, 1)
.unwrap()
.and_hms_micro_opt(0, 0, 1, 444)
.unwrap()
.and_local_timezone(Utc)
.unwrap();
assert_eq!(dt.timestamp_micros(), 1_000_444);
let dt = NaiveDate::from_ymd_opt(2001, 9, 9)
.unwrap()
.and_hms_micro_opt(1, 46, 40, 555)
.unwrap()
.and_local_timezone(Utc)
.unwrap();
assert_eq!(dt.timestamp_micros(), 1_000_000_000_000_555);
sourcepub const fn timestamp_nanos(&self) -> i64
👎Deprecated since 0.4.31: use timestamp_nanos_opt()
instead
pub const fn timestamp_nanos(&self) -> i64
timestamp_nanos_opt()
insteadReturns the number of non-leap-nanoseconds since January 1, 1970 UTC.
§Panics
An i64
with nanosecond precision can span a range of ~584 years. This function panics on
an out of range DateTime
.
The dates that can be represented as nanoseconds are between 1677-09-21T00:12:43.145224192 and 2262-04-11T23:47:16.854775807.
sourcepub const fn timestamp_nanos_opt(&self) -> Option<i64>
pub const fn timestamp_nanos_opt(&self) -> Option<i64>
Returns the number of non-leap-nanoseconds since January 1, 1970 UTC.
§Errors
An i64
with nanosecond precision can span a range of ~584 years. This function returns
None
on an out of range DateTime
.
The dates that can be represented as nanoseconds are between 1677-09-21T00:12:43.145224192 and 2262-04-11T23:47:16.854775807.
§Example
use chrono::{NaiveDate, Utc};
let dt = NaiveDate::from_ymd_opt(1970, 1, 1)
.unwrap()
.and_hms_nano_opt(0, 0, 1, 444)
.unwrap()
.and_local_timezone(Utc)
.unwrap();
assert_eq!(dt.timestamp_nanos_opt(), Some(1_000_000_444));
let dt = NaiveDate::from_ymd_opt(2001, 9, 9)
.unwrap()
.and_hms_nano_opt(1, 46, 40, 555)
.unwrap()
.and_local_timezone(Utc)
.unwrap();
assert_eq!(dt.timestamp_nanos_opt(), Some(1_000_000_000_000_000_555));
let dt = NaiveDate::from_ymd_opt(1677, 9, 21)
.unwrap()
.and_hms_nano_opt(0, 12, 43, 145_224_192)
.unwrap()
.and_local_timezone(Utc)
.unwrap();
assert_eq!(dt.timestamp_nanos_opt(), Some(-9_223_372_036_854_775_808));
let dt = NaiveDate::from_ymd_opt(2262, 4, 11)
.unwrap()
.and_hms_nano_opt(23, 47, 16, 854_775_807)
.unwrap()
.and_local_timezone(Utc)
.unwrap();
assert_eq!(dt.timestamp_nanos_opt(), Some(9_223_372_036_854_775_807));
let dt = NaiveDate::from_ymd_opt(1677, 9, 21)
.unwrap()
.and_hms_nano_opt(0, 12, 43, 145_224_191)
.unwrap()
.and_local_timezone(Utc)
.unwrap();
assert_eq!(dt.timestamp_nanos_opt(), None);
let dt = NaiveDate::from_ymd_opt(2262, 4, 11)
.unwrap()
.and_hms_nano_opt(23, 47, 16, 854_775_808)
.unwrap()
.and_local_timezone(Utc)
.unwrap();
assert_eq!(dt.timestamp_nanos_opt(), None);
sourcepub const fn timestamp_subsec_millis(&self) -> u32
pub const fn timestamp_subsec_millis(&self) -> u32
Returns the number of milliseconds since the last second boundary.
In event of a leap second this may exceed 999.
sourcepub const fn timestamp_subsec_micros(&self) -> u32
pub const fn timestamp_subsec_micros(&self) -> u32
Returns the number of microseconds since the last second boundary.
In event of a leap second this may exceed 999,999.
sourcepub const fn timestamp_subsec_nanos(&self) -> u32
pub const fn timestamp_subsec_nanos(&self) -> u32
Returns the number of nanoseconds since the last second boundary
In event of a leap second this may exceed 999,999,999.
sourcepub const fn offset(&self) -> &<Tz as TimeZone>::Offset
pub const fn offset(&self) -> &<Tz as TimeZone>::Offset
Retrieves an associated offset from UTC.
sourcepub fn with_timezone<Tz2>(&self, tz: &Tz2) -> DateTime<Tz2>where
Tz2: TimeZone,
pub fn with_timezone<Tz2>(&self, tz: &Tz2) -> DateTime<Tz2>where
Tz2: TimeZone,
Changes the associated time zone.
The returned DateTime
references the same instant of time from the perspective of the
provided time zone.
sourcepub fn fixed_offset(&self) -> DateTime<FixedOffset>
pub fn fixed_offset(&self) -> DateTime<FixedOffset>
Fix the offset from UTC to its current value, dropping the associated timezone information.
This it useful for converting a generic DateTime<Tz: Timezone>
to DateTime<FixedOffset>
.
sourcepub const fn to_utc(&self) -> DateTime<Utc>
pub const fn to_utc(&self) -> DateTime<Utc>
Turn this DateTime
into a DateTime<Utc>
, dropping the offset and associated timezone
information.
sourcepub fn checked_add_signed(self, rhs: TimeDelta) -> Option<DateTime<Tz>>
pub fn checked_add_signed(self, rhs: TimeDelta) -> Option<DateTime<Tz>>
Adds given TimeDelta
to the current date and time.
§Errors
Returns None
if the resulting date would be out of range.
sourcepub fn checked_add_months(self, months: Months) -> Option<DateTime<Tz>>
pub fn checked_add_months(self, months: Months) -> Option<DateTime<Tz>>
Adds given Months
to the current date and time.
Uses the last day of the month if the day does not exist in the resulting month.
See NaiveDate::checked_add_months
for more details on behavior.
§Errors
Returns None
if:
- The local time at the resulting date does not exist or is ambiguous, for example during a daylight saving time transition.
- The resulting UTC datetime would be out of range.
- The resulting local datetime would be out of range (unless
months
is zero).
sourcepub fn checked_sub_signed(self, rhs: TimeDelta) -> Option<DateTime<Tz>>
pub fn checked_sub_signed(self, rhs: TimeDelta) -> Option<DateTime<Tz>>
Subtracts given TimeDelta
from the current date and time.
§Errors
Returns None
if the resulting date would be out of range.
sourcepub fn checked_sub_months(self, months: Months) -> Option<DateTime<Tz>>
pub fn checked_sub_months(self, months: Months) -> Option<DateTime<Tz>>
Subtracts given Months
from the current date and time.
Uses the last day of the month if the day does not exist in the resulting month.
See NaiveDate::checked_sub_months
for more details on behavior.
§Errors
Returns None
if:
- The local time at the resulting date does not exist or is ambiguous, for example during a daylight saving time transition.
- The resulting UTC datetime would be out of range.
- The resulting local datetime would be out of range (unless
months
is zero).
sourcepub fn checked_add_days(self, days: Days) -> Option<DateTime<Tz>>
pub fn checked_add_days(self, days: Days) -> Option<DateTime<Tz>>
Add a duration in Days
to the date part of the DateTime
.
§Errors
Returns None
if:
- The local time at the resulting date does not exist or is ambiguous, for example during a daylight saving time transition.
- The resulting UTC datetime would be out of range.
- The resulting local datetime would be out of range (unless
days
is zero).
sourcepub fn checked_sub_days(self, days: Days) -> Option<DateTime<Tz>>
pub fn checked_sub_days(self, days: Days) -> Option<DateTime<Tz>>
Subtract a duration in Days
from the date part of the DateTime
.
§Errors
Returns None
if:
- The local time at the resulting date does not exist or is ambiguous, for example during a daylight saving time transition.
- The resulting UTC datetime would be out of range.
- The resulting local datetime would be out of range (unless
days
is zero).
sourcepub fn signed_duration_since<Tz2>(
self,
rhs: impl Borrow<DateTime<Tz2>>,
) -> TimeDeltawhere
Tz2: TimeZone,
pub fn signed_duration_since<Tz2>(
self,
rhs: impl Borrow<DateTime<Tz2>>,
) -> TimeDeltawhere
Tz2: TimeZone,
Subtracts another DateTime
from the current date and time.
This does not overflow or underflow at all.
sourcepub const fn naive_utc(&self) -> NaiveDateTime
pub const fn naive_utc(&self) -> NaiveDateTime
Returns a view to the naive UTC datetime.
sourcepub fn naive_local(&self) -> NaiveDateTime
pub fn naive_local(&self) -> NaiveDateTime
Returns a view to the naive local datetime.
§Panics
DateTime
internally stores the date and time in UTC with a NaiveDateTime
. This
method will panic if the offset from UTC would push the local datetime outside of the
representable range of a NaiveDateTime
.
sourcepub fn years_since(&self, base: DateTime<Tz>) -> Option<u32>
pub fn years_since(&self, base: DateTime<Tz>) -> Option<u32>
sourcepub fn to_rfc2822(&self) -> String
pub fn to_rfc2822(&self) -> String
Returns an RFC 2822 date and time string such as Tue, 1 Jul 2003 10:52:37 +0200
.
§Panics
Panics if the date can not be represented in this format: the year may not be negative and can not have more than 4 digits.
sourcepub fn to_rfc3339(&self) -> String
pub fn to_rfc3339(&self) -> String
Returns an RFC 3339 and ISO 8601 date and time string such as 1996-12-19T16:39:57-08:00
.
sourcepub fn to_rfc3339_opts(&self, secform: SecondsFormat, use_z: bool) -> String
pub fn to_rfc3339_opts(&self, secform: SecondsFormat, use_z: bool) -> String
Return an RFC 3339 and ISO 8601 date and time string with subseconds
formatted as per SecondsFormat
.
If use_z
is true and the timezone is UTC (offset 0), uses Z
as
per Fixed::TimezoneOffsetColonZ
. If use_z
is false, uses
Fixed::TimezoneOffsetColon
§Examples
let dt = NaiveDate::from_ymd_opt(2018, 1, 26)
.unwrap()
.and_hms_micro_opt(18, 30, 9, 453_829)
.unwrap()
.and_utc();
assert_eq!(dt.to_rfc3339_opts(SecondsFormat::Millis, false), "2018-01-26T18:30:09.453+00:00");
assert_eq!(dt.to_rfc3339_opts(SecondsFormat::Millis, true), "2018-01-26T18:30:09.453Z");
assert_eq!(dt.to_rfc3339_opts(SecondsFormat::Secs, true), "2018-01-26T18:30:09Z");
let pst = FixedOffset::east_opt(8 * 60 * 60).unwrap();
let dt = pst
.from_local_datetime(
&NaiveDate::from_ymd_opt(2018, 1, 26)
.unwrap()
.and_hms_micro_opt(10, 30, 9, 453_829)
.unwrap(),
)
.unwrap();
assert_eq!(dt.to_rfc3339_opts(SecondsFormat::Secs, true), "2018-01-26T10:30:09+08:00");
sourcepub fn with_time(&self, time: NaiveTime) -> LocalResult<DateTime<Tz>>
pub fn with_time(&self, time: NaiveTime) -> LocalResult<DateTime<Tz>>
Set the time to a new fixed time on the existing date.
§Errors
Returns LocalResult::None
if the datetime is at the edge of the representable range for a
DateTime
, and with_time
would push the value in UTC out of range.
§Example
use chrono::{Local, NaiveTime};
let noon = NaiveTime::from_hms_opt(12, 0, 0).unwrap();
let today_noon = Local::now().with_time(noon);
let today_midnight = Local::now().with_time(NaiveTime::MIN);
assert_eq!(today_noon.single().unwrap().time(), noon);
assert_eq!(today_midnight.single().unwrap().time(), NaiveTime::MIN);
source§impl DateTime<Utc>
impl DateTime<Utc>
sourcepub const fn from_timestamp(secs: i64, nsecs: u32) -> Option<DateTime<Utc>>
pub const fn from_timestamp(secs: i64, nsecs: u32) -> Option<DateTime<Utc>>
Makes a new DateTime<Utc>
from the number of non-leap seconds
since January 1, 1970 0:00:00 UTC (aka “UNIX timestamp”)
and the number of nanoseconds since the last whole non-leap second.
This is guaranteed to round-trip with regard to timestamp
and
timestamp_subsec_nanos
.
If you need to create a DateTime
with a TimeZone
different from Utc
, use
TimeZone::timestamp_opt
or DateTime::with_timezone
.
The nanosecond part can exceed 1,000,000,000 in order to represent a
leap second, but only when secs % 60 == 59
.
(The true “UNIX timestamp” cannot represent a leap second unambiguously.)
§Errors
Returns None
on out-of-range number of seconds and/or
invalid nanosecond, otherwise returns Some(DateTime {...})
.
§Example
use chrono::DateTime;
let dt = DateTime::from_timestamp(1431648000, 0).expect("invalid timestamp");
assert_eq!(dt.to_string(), "2015-05-15 00:00:00 UTC");
assert_eq!(DateTime::from_timestamp(dt.timestamp(), dt.timestamp_subsec_nanos()).unwrap(), dt);
sourcepub const fn from_timestamp_millis(millis: i64) -> Option<DateTime<Utc>>
pub const fn from_timestamp_millis(millis: i64) -> Option<DateTime<Utc>>
Makes a new DateTime<Utc>
from the number of non-leap milliseconds
since January 1, 1970 0:00:00.000 UTC (aka “UNIX timestamp”).
This is guaranteed to round-trip with timestamp_millis
.
If you need to create a DateTime
with a TimeZone
different from Utc
, use
TimeZone::timestamp_millis_opt
or DateTime::with_timezone
.
§Errors
Returns None
on out-of-range number of milliseconds, otherwise returns Some(DateTime {...})
.
§Example
use chrono::DateTime;
let dt = DateTime::from_timestamp_millis(947638923004).expect("invalid timestamp");
assert_eq!(dt.to_string(), "2000-01-12 01:02:03.004 UTC");
assert_eq!(DateTime::from_timestamp_millis(dt.timestamp_millis()).unwrap(), dt);
sourcepub const fn from_timestamp_micros(micros: i64) -> Option<DateTime<Utc>>
pub const fn from_timestamp_micros(micros: i64) -> Option<DateTime<Utc>>
Creates a new DateTime<Utc>
from the number of non-leap microseconds
since January 1, 1970 0:00:00.000 UTC (aka “UNIX timestamp”).
This is guaranteed to round-trip with timestamp_micros
.
If you need to create a DateTime
with a TimeZone
different from Utc
, use
TimeZone::timestamp_micros
or DateTime::with_timezone
.
§Errors
Returns None
if the number of microseconds would be out of range for a NaiveDateTime
(more than ca. 262,000 years away from common era)
§Example
use chrono::DateTime;
let timestamp_micros: i64 = 1662921288000000; // Sun, 11 Sep 2022 18:34:48 UTC
let dt = DateTime::from_timestamp_micros(timestamp_micros);
assert!(dt.is_some());
assert_eq!(timestamp_micros, dt.expect("invalid timestamp").timestamp_micros());
// Negative timestamps (before the UNIX epoch) are supported as well.
let timestamp_micros: i64 = -2208936075000000; // Mon, 1 Jan 1900 14:38:45 UTC
let dt = DateTime::from_timestamp_micros(timestamp_micros);
assert!(dt.is_some());
assert_eq!(timestamp_micros, dt.expect("invalid timestamp").timestamp_micros());
sourcepub const fn from_timestamp_nanos(nanos: i64) -> DateTime<Utc>
pub const fn from_timestamp_nanos(nanos: i64) -> DateTime<Utc>
Creates a new DateTime<Utc>
from the number of non-leap microseconds
since January 1, 1970 0:00:00.000 UTC (aka “UNIX timestamp”).
This is guaranteed to round-trip with timestamp_nanos
.
If you need to create a DateTime
with a TimeZone
different from Utc
, use
TimeZone::timestamp_nanos
or DateTime::with_timezone
.
The UNIX epoch starts on midnight, January 1, 1970, UTC.
An i64
with nanosecond precision can span a range of ~584 years. Because all values can
be represented as a DateTime
this method never fails.
§Example
use chrono::DateTime;
let timestamp_nanos: i64 = 1662921288_000_000_000; // Sun, 11 Sep 2022 18:34:48 UTC
let dt = DateTime::from_timestamp_nanos(timestamp_nanos);
assert_eq!(timestamp_nanos, dt.timestamp_nanos_opt().unwrap());
// Negative timestamps (before the UNIX epoch) are supported as well.
let timestamp_nanos: i64 = -2208936075_000_000_000; // Mon, 1 Jan 1900 14:38:45 UTC
let dt = DateTime::from_timestamp_nanos(timestamp_nanos);
assert_eq!(timestamp_nanos, dt.timestamp_nanos_opt().unwrap());
sourcepub const UNIX_EPOCH: DateTime<Utc> = _
pub const UNIX_EPOCH: DateTime<Utc> = _
The Unix Epoch, 1970-01-01 00:00:00 UTC.
source§impl DateTime<FixedOffset>
impl DateTime<FixedOffset>
sourcepub fn parse_from_rfc2822(s: &str) -> Result<DateTime<FixedOffset>, ParseError>
pub fn parse_from_rfc2822(s: &str) -> Result<DateTime<FixedOffset>, ParseError>
Parses an RFC 2822 date-and-time string into a DateTime<FixedOffset>
value.
This parses valid RFC 2822 datetime strings (such as Tue, 1 Jul 2003 10:52:37 +0200
)
and returns a new DateTime
instance with the parsed timezone as the FixedOffset
.
RFC 2822 is the internet message standard that specifies the representation of times in HTTP and email headers. It is the 2001 revision of RFC 822, and is itself revised as RFC 5322 in 2008.
§Support for the obsolete date format
- A 2-digit year is interpreted to be a year in 1950-2049.
- The standard allows comments and whitespace between many of the tokens. See 4.3 and Appendix A.5
- Single letter ‘military’ time zone names are parsed as a
-0000
offset. They were defined with the wrong sign in RFC 822 and corrected in RFC 2822. But because the meaning is now ambiguous, the standard says they should be be considered as-0000
unless there is out-of-band information confirming their meaning. The exception isZ
, which remains identical to+0000
.
§Example
assert_eq!(
DateTime::parse_from_rfc2822("Wed, 18 Feb 2015 23:16:09 GMT").unwrap(),
FixedOffset::east_opt(0).unwrap().with_ymd_and_hms(2015, 2, 18, 23, 16, 9).unwrap()
);
sourcepub fn parse_from_rfc3339(s: &str) -> Result<DateTime<FixedOffset>, ParseError>
pub fn parse_from_rfc3339(s: &str) -> Result<DateTime<FixedOffset>, ParseError>
Parses an RFC 3339 date-and-time string into a DateTime<FixedOffset>
value.
Parses all valid RFC 3339 values (as well as the subset of valid ISO 8601 values that are
also valid RFC 3339 date-and-time values) and returns a new DateTime
with a
FixedOffset
corresponding to the parsed timezone. While RFC 3339 values come in a wide
variety of shapes and sizes, 1996-12-19T16:39:57-08:00
is an example of the most commonly
encountered variety of RFC 3339 formats.
Why isn’t this named parse_from_iso8601
? That’s because ISO 8601 allows representing
values in a wide range of formats, only some of which represent actual date-and-time
instances (rather than periods, ranges, dates, or times). Some valid ISO 8601 values are
also simultaneously valid RFC 3339 values, but not all RFC 3339 values are valid ISO 8601
values (or the other way around).
sourcepub fn parse_from_str(
s: &str,
fmt: &str,
) -> Result<DateTime<FixedOffset>, ParseError>
pub fn parse_from_str( s: &str, fmt: &str, ) -> Result<DateTime<FixedOffset>, ParseError>
Parses a string from a user-specified format into a DateTime<FixedOffset>
value.
Note that this method requires a timezone in the input string. See
NaiveDateTime::parse_from_str
for a version that does not require a timezone in the to-be-parsed str. The returned
DateTime
value will have a FixedOffset
reflecting the parsed timezone.
See the format::strftime
module for supported format
sequences.
§Example
use chrono::{DateTime, FixedOffset, NaiveDate, TimeZone};
let dt = DateTime::parse_from_str("1983 Apr 13 12:09:14.274 +0000", "%Y %b %d %H:%M:%S%.3f %z");
assert_eq!(
dt,
Ok(FixedOffset::east_opt(0)
.unwrap()
.from_local_datetime(
&NaiveDate::from_ymd_opt(1983, 4, 13)
.unwrap()
.and_hms_milli_opt(12, 9, 14, 274)
.unwrap()
)
.unwrap())
);
sourcepub fn parse_and_remainder<'a>(
s: &'a str,
fmt: &str,
) -> Result<(DateTime<FixedOffset>, &'a str), ParseError>
pub fn parse_and_remainder<'a>( s: &'a str, fmt: &str, ) -> Result<(DateTime<FixedOffset>, &'a str), ParseError>
Parses a string from a user-specified format into a DateTime<FixedOffset>
value, and a
slice with the remaining portion of the string.
Note that this method requires a timezone in the input string. See
NaiveDateTime::parse_and_remainder
for a version that does not
require a timezone in s
. The returned DateTime
value will have a FixedOffset
reflecting the parsed timezone.
See the format::strftime
module for supported format
sequences.
Similar to parse_from_str
.
§Example
let (datetime, remainder) = DateTime::parse_and_remainder(
"2015-02-18 23:16:09 +0200 trailing text",
"%Y-%m-%d %H:%M:%S %z",
)
.unwrap();
assert_eq!(
datetime,
FixedOffset::east_opt(2 * 3600).unwrap().with_ymd_and_hms(2015, 2, 18, 23, 16, 9).unwrap()
);
assert_eq!(remainder, " trailing text");
source§impl<Tz> DateTime<Tz>
impl<Tz> DateTime<Tz>
sourcepub fn format_with_items<'a, I, B>(&self, items: I) -> DelayedFormat<I>
pub fn format_with_items<'a, I, B>(&self, items: I) -> DelayedFormat<I>
Formats the combined date and time with the specified formatting items.
sourcepub fn format<'a>(&self, fmt: &'a str) -> DelayedFormat<StrftimeItems<'a>>
pub fn format<'a>(&self, fmt: &'a str) -> DelayedFormat<StrftimeItems<'a>>
Formats the combined date and time per the specified format string.
See the crate::format::strftime
module for the supported escape sequences.
§Example
use chrono::prelude::*;
let date_time: DateTime<Utc> = Utc.with_ymd_and_hms(2017, 04, 02, 12, 50, 32).unwrap();
let formatted = format!("{}", date_time.format("%d/%m/%Y %H:%M"));
assert_eq!(formatted, "02/04/2017 12:50");
Trait Implementations§
source§impl<Tz> Add<Days> for DateTime<Tz>where
Tz: TimeZone,
impl<Tz> Add<Days> for DateTime<Tz>where
Tz: TimeZone,
Add Days
to NaiveDateTime
.
§Panics
Panics if:
- The resulting date would be out of range.
- The local time at the resulting date does not exist or is ambiguous, for example during a daylight saving time transition.
Strongly consider using DateTime<Tz>::checked_sub_days
to get an Option
instead.
source§impl<Tz> Add<Duration> for DateTime<Tz>where
Tz: TimeZone,
impl<Tz> Add<Duration> for DateTime<Tz>where
Tz: TimeZone,
Add std::time::Duration
to DateTime
.
As a part of Chrono’s [leap second handling], the addition assumes that there is no leap
second ever, except when the NaiveDateTime
itself represents a leap second in which case
the assumption becomes that there is exactly a single leap second ever.
§Panics
Panics if the resulting date would be out of range.
Consider using DateTime<Tz>::checked_add_signed
to get an Option
instead.
source§impl<Tz> Add<FixedOffset> for DateTime<Tz>where
Tz: TimeZone,
impl<Tz> Add<FixedOffset> for DateTime<Tz>where
Tz: TimeZone,
Add FixedOffset
to the datetime value of DateTime
(offset remains unchanged).
§Panics
Panics if the resulting date would be out of range.
source§impl<Tz> Add<Months> for DateTime<Tz>where
Tz: TimeZone,
impl<Tz> Add<Months> for DateTime<Tz>where
Tz: TimeZone,
Add Months
to DateTime
.
The result will be clamped to valid days in the resulting month, see checked_add_months
for
details.
§Panics
Panics if:
- The resulting date would be out of range.
- The local time at the resulting date does not exist or is ambiguous, for example during a daylight saving time transition.
Strongly consider using DateTime<Tz>::checked_add_months
to get an Option
instead.
source§impl<Tz> Add<TimeDelta> for DateTime<Tz>where
Tz: TimeZone,
impl<Tz> Add<TimeDelta> for DateTime<Tz>where
Tz: TimeZone,
Add TimeDelta
to DateTime
.
As a part of Chrono’s [leap second handling], the addition assumes that there is no leap
second ever, except when the NaiveDateTime
itself represents a leap second in which case
the assumption becomes that there is exactly a single leap second ever.
§Panics
Panics if the resulting date would be out of range.
Consider using DateTime<Tz>::checked_add_signed
to get an Option
instead.
source§impl<Tz> AddAssign<Duration> for DateTime<Tz>where
Tz: TimeZone,
impl<Tz> AddAssign<Duration> for DateTime<Tz>where
Tz: TimeZone,
Add-assign std::time::Duration
to DateTime
.
As a part of Chrono’s [leap second handling], the addition assumes that there is no leap
second ever, except when the NaiveDateTime
itself represents a leap second in which case
the assumption becomes that there is exactly a single leap second ever.
§Panics
Panics if the resulting date would be out of range.
Consider using DateTime<Tz>::checked_add_signed
to get an Option
instead.
source§fn add_assign(&mut self, rhs: Duration)
fn add_assign(&mut self, rhs: Duration)
+=
operation. Read moresource§impl<Tz> AddAssign<TimeDelta> for DateTime<Tz>where
Tz: TimeZone,
impl<Tz> AddAssign<TimeDelta> for DateTime<Tz>where
Tz: TimeZone,
Add-assign chrono::Duration
to DateTime
.
As a part of Chrono’s [leap second handling], the addition assumes that there is no leap
second ever, except when the NaiveDateTime
itself represents a leap second in which case
the assumption becomes that there is exactly a single leap second ever.
§Panics
Panics if the resulting date would be out of range.
Consider using DateTime<Tz>::checked_add_signed
to get an Option
instead.
source§fn add_assign(&mut self, rhs: TimeDelta)
fn add_assign(&mut self, rhs: TimeDelta)
+=
operation. Read moresource§impl<Tz> Datelike for DateTime<Tz>where
Tz: TimeZone,
impl<Tz> Datelike for DateTime<Tz>where
Tz: TimeZone,
source§fn with_year(&self, year: i32) -> Option<DateTime<Tz>>
fn with_year(&self, year: i32) -> Option<DateTime<Tz>>
Makes a new DateTime
with the year number changed, while keeping the same month and day.
See also the NaiveDate::with_year
method.
§Errors
Returns None
if:
- The resulting date does not exist (February 29 in a non-leap year).
- The local time at the resulting date does not exist or is ambiguous, for example during a daylight saving time transition.
- The resulting UTC datetime would be out of range.
- The resulting local datetime would be out of range (unless the year remains the same).
source§fn with_month(&self, month: u32) -> Option<DateTime<Tz>>
fn with_month(&self, month: u32) -> Option<DateTime<Tz>>
Makes a new DateTime
with the month number (starting from 1) changed.
Don’t combine multiple Datelike::with_*
methods. The intermediate value may not exist.
See also the NaiveDate::with_month
method.
§Errors
Returns None
if:
- The resulting date does not exist (for example
month(4)
when day of the month is 31). - The value for
month
is invalid. - The local time at the resulting date does not exist or is ambiguous, for example during a daylight saving time transition.
source§fn with_month0(&self, month0: u32) -> Option<DateTime<Tz>>
fn with_month0(&self, month0: u32) -> Option<DateTime<Tz>>
Makes a new DateTime
with the month number (starting from 0) changed.
See also the NaiveDate::with_month0
method.
§Errors
Returns None
if:
- The resulting date does not exist (for example
month0(3)
when day of the month is 31). - The value for
month0
is invalid. - The local time at the resulting date does not exist or is ambiguous, for example during a daylight saving time transition.
source§fn with_day(&self, day: u32) -> Option<DateTime<Tz>>
fn with_day(&self, day: u32) -> Option<DateTime<Tz>>
Makes a new DateTime
with the day of month (starting from 1) changed.
See also the NaiveDate::with_day
method.
§Errors
Returns None
if:
- The resulting date does not exist (for example
day(31)
in April). - The value for
day
is invalid. - The local time at the resulting date does not exist or is ambiguous, for example during a daylight saving time transition.
source§fn with_day0(&self, day0: u32) -> Option<DateTime<Tz>>
fn with_day0(&self, day0: u32) -> Option<DateTime<Tz>>
Makes a new DateTime
with the day of month (starting from 0) changed.
See also the NaiveDate::with_day0
method.
§Errors
Returns None
if:
- The resulting date does not exist (for example
day(30)
in April). - The value for
day0
is invalid. - The local time at the resulting date does not exist or is ambiguous, for example during a daylight saving time transition.
source§fn with_ordinal(&self, ordinal: u32) -> Option<DateTime<Tz>>
fn with_ordinal(&self, ordinal: u32) -> Option<DateTime<Tz>>
Makes a new DateTime
with the day of year (starting from 1) changed.
See also the NaiveDate::with_ordinal
method.
§Errors
Returns None
if:
- The resulting date does not exist (
with_ordinal(366)
in a non-leap year). - The value for
ordinal
is invalid. - The local time at the resulting date does not exist or is ambiguous, for example during a daylight saving time transition.
source§fn with_ordinal0(&self, ordinal0: u32) -> Option<DateTime<Tz>>
fn with_ordinal0(&self, ordinal0: u32) -> Option<DateTime<Tz>>
Makes a new DateTime
with the day of year (starting from 0) changed.
See also the NaiveDate::with_ordinal0
method.
§Errors
Returns None
if:
- The resulting date does not exist (
with_ordinal0(365)
in a non-leap year). - The value for
ordinal0
is invalid. - The local time at the resulting date does not exist or is ambiguous, for example during a daylight saving time transition.
source§fn year(&self) -> i32
fn year(&self) -> i32
source§fn year_ce(&self) -> (bool, u32)
fn year_ce(&self) -> (bool, u32)
source§fn num_days_from_ce(&self) -> i32
fn num_days_from_ce(&self) -> i32
source§impl Default for DateTime<FixedOffset>
impl Default for DateTime<FixedOffset>
source§impl<'de> Deserialize<'de> for DateTime<FixedOffset>
impl<'de> Deserialize<'de> for DateTime<FixedOffset>
Deserialize an RFC 3339 formatted string into a DateTime<FixedOffset>
As an extension to RFC 3339 this can deserialize to DateTime
s outside the range of 0-9999
years using an ISO 8601 syntax (which prepends an -
or +
).
See the serde
module for alternate deserialization formats.
source§fn deserialize<D>(
deserializer: D,
) -> Result<DateTime<FixedOffset>, <D as Deserializer<'de>>::Error>where
D: Deserializer<'de>,
fn deserialize<D>(
deserializer: D,
) -> Result<DateTime<FixedOffset>, <D as Deserializer<'de>>::Error>where
D: Deserializer<'de>,
source§impl<'de> Deserialize<'de> for DateTime<Local>
impl<'de> Deserialize<'de> for DateTime<Local>
Deserialize an RFC 3339 formatted string into a DateTime<Local>
The value will remain the same instant in UTC, but the offset will be recalculated to match
that of the Local
platform time zone.
As an extension to RFC 3339 this can deserialize to DateTime
s outside the range of 0-9999
years using an ISO 8601 syntax (which prepends an -
or +
).
See the serde
module for alternate deserialization formats.
source§fn deserialize<D>(
deserializer: D,
) -> Result<DateTime<Local>, <D as Deserializer<'de>>::Error>where
D: Deserializer<'de>,
fn deserialize<D>(
deserializer: D,
) -> Result<DateTime<Local>, <D as Deserializer<'de>>::Error>where
D: Deserializer<'de>,
source§impl<'de> Deserialize<'de> for DateTime<Utc>
impl<'de> Deserialize<'de> for DateTime<Utc>
Deserialize an RFC 3339 formatted string into a DateTime<Utc>
If the value contains an offset from UTC that is not zero, the value will be converted to UTC.
As an extension to RFC 3339 this can deserialize to DateTime
s outside the range of 0-9999
years using an ISO 8601 syntax (which prepends an -
or +
).
See the serde
module for alternate deserialization formats.
source§fn deserialize<D>(
deserializer: D,
) -> Result<DateTime<Utc>, <D as Deserializer<'de>>::Error>where
D: Deserializer<'de>,
fn deserialize<D>(
deserializer: D,
) -> Result<DateTime<Utc>, <D as Deserializer<'de>>::Error>where
D: Deserializer<'de>,
source§impl<Tz> DurationRound for DateTime<Tz>where
Tz: TimeZone,
impl<Tz> DurationRound for DateTime<Tz>where
Tz: TimeZone,
§type Err = RoundingError
type Err = RoundingError
source§fn duration_round(
self,
duration: TimeDelta,
) -> Result<DateTime<Tz>, <DateTime<Tz> as DurationRound>::Err>
fn duration_round( self, duration: TimeDelta, ) -> Result<DateTime<Tz>, <DateTime<Tz> as DurationRound>::Err>
source§fn duration_trunc(
self,
duration: TimeDelta,
) -> Result<DateTime<Tz>, <DateTime<Tz> as DurationRound>::Err>
fn duration_trunc( self, duration: TimeDelta, ) -> Result<DateTime<Tz>, <DateTime<Tz> as DurationRound>::Err>
source§impl From<DateTime<FixedOffset>> for DateTime<Local>
impl From<DateTime<FixedOffset>> for DateTime<Local>
Convert a DateTime<FixedOffset>
instance into a DateTime<Local>
instance.
source§fn from(src: DateTime<FixedOffset>) -> DateTime<Local>
fn from(src: DateTime<FixedOffset>) -> DateTime<Local>
Convert this DateTime<FixedOffset>
instance into a DateTime<Local>
instance.
Conversion is performed via DateTime::with_timezone
. Returns the equivalent value in local
time.
source§impl From<DateTime<FixedOffset>> for DateTime<Utc>
impl From<DateTime<FixedOffset>> for DateTime<Utc>
Convert a DateTime<FixedOffset>
instance into a DateTime<Utc>
instance.
source§fn from(src: DateTime<FixedOffset>) -> DateTime<Utc>
fn from(src: DateTime<FixedOffset>) -> DateTime<Utc>
Convert this DateTime<FixedOffset>
instance into a DateTime<Utc>
instance.
Conversion is performed via DateTime::with_timezone
, accounting for the timezone
difference.
source§impl From<DateTime<Local>> for DateTime<FixedOffset>
impl From<DateTime<Local>> for DateTime<FixedOffset>
Convert a DateTime<Local>
instance into a DateTime<FixedOffset>
instance.
source§fn from(src: DateTime<Local>) -> DateTime<FixedOffset>
fn from(src: DateTime<Local>) -> DateTime<FixedOffset>
Convert this DateTime<Local>
instance into a DateTime<FixedOffset>
instance.
Conversion is performed via DateTime::with_timezone
.
source§impl From<DateTime<Local>> for DateTime<Utc>
impl From<DateTime<Local>> for DateTime<Utc>
Convert a DateTime<Local>
instance into a DateTime<Utc>
instance.
source§impl From<DateTime<Utc>> for DateTime<FixedOffset>
impl From<DateTime<Utc>> for DateTime<FixedOffset>
Convert a DateTime<Utc>
instance into a DateTime<FixedOffset>
instance.
source§fn from(src: DateTime<Utc>) -> DateTime<FixedOffset>
fn from(src: DateTime<Utc>) -> DateTime<FixedOffset>
Convert this DateTime<Utc>
instance into a DateTime<FixedOffset>
instance.
Conversion is done via DateTime::with_timezone
. Note that the converted value returned by
this will be created with a fixed timezone offset of 0.
source§impl From<DateTime<Utc>> for DateTime<Local>
impl From<DateTime<Utc>> for DateTime<Local>
Convert a DateTime<Utc>
instance into a DateTime<Local>
instance.
source§impl FromStr for DateTime<FixedOffset>
impl FromStr for DateTime<FixedOffset>
Accepts a relaxed form of RFC3339. A space or a ‘T’ are acepted as the separator between the date and time parts. Additional spaces are allowed between each component.
All of these examples are equivalent:
"2012-12-12T12:12:12Z".parse::<DateTime<FixedOffset>>()?;
"2012-12-12 12:12:12Z".parse::<DateTime<FixedOffset>>()?;
"2012- 12-12T12: 12:12Z".parse::<DateTime<FixedOffset>>()?;
§type Err = ParseError
type Err = ParseError
source§fn from_str(s: &str) -> Result<DateTime<FixedOffset>, ParseError>
fn from_str(s: &str) -> Result<DateTime<FixedOffset>, ParseError>
s
to return a value of this type. Read moresource§impl FromStr for DateTime<Local>
impl FromStr for DateTime<Local>
Accepts a relaxed form of RFC3339. A space or a ‘T’ are accepted as the separator between the date and time parts.
All of these examples are equivalent:
"2012-12-12T12:12:12Z".parse::<DateTime<Local>>()?;
"2012-12-12 12:12:12Z".parse::<DateTime<Local>>()?;
"2012-12-12 12:12:12+0000".parse::<DateTime<Local>>()?;
"2012-12-12 12:12:12+00:00".parse::<DateTime<Local>>()?;
source§impl FromStr for DateTime<Utc>
impl FromStr for DateTime<Utc>
Accepts a relaxed form of RFC3339. A space or a ‘T’ are accepted as the separator between the date and time parts.
All of these examples are equivalent:
"2012-12-12T12:12:12Z".parse::<DateTime<Utc>>()?;
"2012-12-12 12:12:12Z".parse::<DateTime<Utc>>()?;
"2012-12-12 12:12:12+0000".parse::<DateTime<Utc>>()?;
"2012-12-12 12:12:12+00:00".parse::<DateTime<Utc>>()?;
source§impl<Tz> Ord for DateTime<Tz>where
Tz: TimeZone,
impl<Tz> Ord for DateTime<Tz>where
Tz: TimeZone,
1.21.0 · source§fn max(self, other: Self) -> Selfwhere
Self: Sized,
fn max(self, other: Self) -> Selfwhere
Self: Sized,
source§impl<Tz, Tz2> PartialEq<DateTime<Tz2>> for DateTime<Tz>
impl<Tz, Tz2> PartialEq<DateTime<Tz2>> for DateTime<Tz>
source§impl<Tz, Tz2> PartialOrd<DateTime<Tz2>> for DateTime<Tz>
impl<Tz, Tz2> PartialOrd<DateTime<Tz2>> for DateTime<Tz>
source§fn partial_cmp(&self, other: &DateTime<Tz2>) -> Option<Ordering>
fn partial_cmp(&self, other: &DateTime<Tz2>) -> Option<Ordering>
Compare two DateTimes based on their true time, ignoring time zones
§Example
use chrono::prelude::*;
let earlier = Utc
.with_ymd_and_hms(2015, 5, 15, 2, 0, 0)
.unwrap()
.with_timezone(&FixedOffset::west_opt(1 * 3600).unwrap());
let later = Utc
.with_ymd_and_hms(2015, 5, 15, 3, 0, 0)
.unwrap()
.with_timezone(&FixedOffset::west_opt(5 * 3600).unwrap());
assert_eq!(earlier.to_string(), "2015-05-15 01:00:00 -01:00");
assert_eq!(later.to_string(), "2015-05-14 22:00:00 -05:00");
assert!(later > earlier);
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<Tz> Serialize for DateTime<Tz>where
Tz: TimeZone,
impl<Tz> Serialize for DateTime<Tz>where
Tz: TimeZone,
Serialize to an RFC 3339 formatted string
As an extension to RFC 3339 this can serialize DateTime
s outside the range of 0-9999 years
using an ISO 8601 syntax (which prepends an -
or +
).
See the serde
module for alternate serializations.
source§fn serialize<S>(
&self,
serializer: S,
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
S: Serializer,
fn serialize<S>(
&self,
serializer: S,
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
S: Serializer,
source§impl<Tz> Sub<Days> for DateTime<Tz>where
Tz: TimeZone,
impl<Tz> Sub<Days> for DateTime<Tz>where
Tz: TimeZone,
Subtract Days
from DateTime
.
§Panics
Panics if:
- The resulting date would be out of range.
- The local time at the resulting date does not exist or is ambiguous, for example during a daylight saving time transition.
Strongly consider using DateTime<Tz>::checked_sub_days
to get an Option
instead.
source§impl<Tz> Sub<Duration> for DateTime<Tz>where
Tz: TimeZone,
impl<Tz> Sub<Duration> for DateTime<Tz>where
Tz: TimeZone,
Subtract std::time::Duration
from DateTime
.
As a part of Chrono’s [leap second handling] the subtraction assumes that there is no leap
second ever, except when the DateTime
itself represents a leap second in which case
the assumption becomes that there is exactly a single leap second ever.
§Panics
Panics if the resulting date would be out of range.
Consider using DateTime<Tz>::checked_sub_signed
to get an Option
instead.
source§impl<Tz> Sub<FixedOffset> for DateTime<Tz>where
Tz: TimeZone,
impl<Tz> Sub<FixedOffset> for DateTime<Tz>where
Tz: TimeZone,
Subtract FixedOffset
from the datetime value of DateTime
(offset remains unchanged).
§Panics
Panics if the resulting date would be out of range.
source§impl<Tz> Sub<Months> for DateTime<Tz>where
Tz: TimeZone,
impl<Tz> Sub<Months> for DateTime<Tz>where
Tz: TimeZone,
Subtract Months
from DateTime
.
The result will be clamped to valid days in the resulting month, see
DateTime<Tz>::checked_sub_months
for details.
§Panics
Panics if:
- The resulting date would be out of range.
- The local time at the resulting date does not exist or is ambiguous, for example during a daylight saving time transition.
Strongly consider using DateTime<Tz>::checked_sub_months
to get an Option
instead.
source§impl<Tz> Sub<TimeDelta> for DateTime<Tz>where
Tz: TimeZone,
impl<Tz> Sub<TimeDelta> for DateTime<Tz>where
Tz: TimeZone,
Subtract TimeDelta
from DateTime
.
This is the same as the addition with a negated TimeDelta
.
As a part of Chrono’s [leap second handling] the subtraction assumes that there is no leap
second ever, except when the DateTime
itself represents a leap second in which case
the assumption becomes that there is exactly a single leap second ever.
§Panics
Panics if the resulting date would be out of range.
Consider using DateTime<Tz>::checked_sub_signed
to get an Option
instead.
source§impl<Tz> SubAssign<Duration> for DateTime<Tz>where
Tz: TimeZone,
impl<Tz> SubAssign<Duration> for DateTime<Tz>where
Tz: TimeZone,
Subtract-assign std::time::Duration
from DateTime
.
As a part of Chrono’s [leap second handling], the addition assumes that there is no leap
second ever, except when the DateTime
itself represents a leap second in which case
the assumption becomes that there is exactly a single leap second ever.
§Panics
Panics if the resulting date would be out of range.
Consider using DateTime<Tz>::checked_sub_signed
to get an Option
instead.
source§fn sub_assign(&mut self, rhs: Duration)
fn sub_assign(&mut self, rhs: Duration)
-=
operation. Read moresource§impl<Tz> SubAssign<TimeDelta> for DateTime<Tz>where
Tz: TimeZone,
impl<Tz> SubAssign<TimeDelta> for DateTime<Tz>where
Tz: TimeZone,
Subtract-assign TimeDelta
from DateTime
.
This is the same as the addition with a negated TimeDelta
.
As a part of Chrono’s [leap second handling], the addition assumes that there is no leap
second ever, except when the DateTime
itself represents a leap second in which case
the assumption becomes that there is exactly a single leap second ever.
§Panics
Panics if the resulting date would be out of range.
Consider using DateTime<Tz>::checked_sub_signed
to get an Option
instead.
source§fn sub_assign(&mut self, rhs: TimeDelta)
fn sub_assign(&mut self, rhs: TimeDelta)
-=
operation. Read moresource§impl<Tz> Timelike for DateTime<Tz>where
Tz: TimeZone,
impl<Tz> Timelike for DateTime<Tz>where
Tz: TimeZone,
source§fn with_hour(&self, hour: u32) -> Option<DateTime<Tz>>
fn with_hour(&self, hour: u32) -> Option<DateTime<Tz>>
Makes a new DateTime
with the hour number changed.
See also the NaiveTime::with_hour
method.
§Errors
Returns None
if:
- The value for
hour
is invalid. - The local time at the resulting date does not exist or is ambiguous, for example during a daylight saving time transition.
source§fn with_minute(&self, min: u32) -> Option<DateTime<Tz>>
fn with_minute(&self, min: u32) -> Option<DateTime<Tz>>
Makes a new DateTime
with the minute number changed.
See also the NaiveTime::with_minute
method.
§Errors
- The value for
minute
is invalid. - The local time at the resulting date does not exist or is ambiguous, for example during a daylight saving time transition.
source§fn with_second(&self, sec: u32) -> Option<DateTime<Tz>>
fn with_second(&self, sec: u32) -> Option<DateTime<Tz>>
Makes a new DateTime
with the second number changed.
As with the second
method,
the input range is restricted to 0 through 59.
See also the NaiveTime::with_second
method.
§Errors
Returns None
if:
- The value for
second
is invalid. - The local time at the resulting date does not exist or is ambiguous, for example during a daylight saving time transition.
source§fn with_nanosecond(&self, nano: u32) -> Option<DateTime<Tz>>
fn with_nanosecond(&self, nano: u32) -> Option<DateTime<Tz>>
Makes a new DateTime
with nanoseconds since the whole non-leap second changed.
Returns None
when the resulting NaiveDateTime
would be invalid.
As with the NaiveDateTime::nanosecond
method,
the input range can exceed 1,000,000,000 for leap seconds.
See also the NaiveTime::with_nanosecond
method.
§Errors
Returns None
if nanosecond >= 2,000,000,000
.