Struct chrono::DateTime

pub struct DateTime<Tz: TimeZone> { /* private fields */ }

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

impl<Tz: TimeZone> DateTime<Tz>

pub const fn from_naive_utc_and_offset( datetime: NaiveDateTime, offset: Tz::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);

pub fn from_utc(datetime: NaiveDateTime, offset: Tz::Offset) -> DateTime<Tz>

👎Deprecated since 0.4.27: Use TimeZone::from_utc_datetime() or DateTime::from_naive_utc_and_offset instead

Makes a new DateTime from its components: a NaiveDateTime in UTC and an Offset.

pub fn from_local(datetime: NaiveDateTime, offset: Tz::Offset) -> DateTime<Tz>

👎Deprecated since 0.4.27: Use TimeZone::from_local_datetime() or NaiveDateTime::and_local_timezone instead

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.

pub fn date(&self) -> Date<Tz>

👎Deprecated since 0.4.23: Use date_naive() instead

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

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());

pub fn time(&self) -> NaiveTime

Retrieves the time component.

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

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

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

pub const fn timestamp_nanos(&self) -> i64

👎Deprecated since 0.4.31: use timestamp_nanos_opt() instead

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

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

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.

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.

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.

pub const fn offset(&self) -> &Tz::Offset

Retrieves an associated offset from UTC.

pub fn timezone(&self) -> Tz

Retrieves an associated time zone.

pub fn with_timezone<Tz2: TimeZone>(&self, tz: &Tz2) -> DateTime<Tz2>

Changes the associated time zone. The returned DateTime references the same instant of time from the perspective of the provided time zone.

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

pub const fn to_utc(&self) -> DateTime<Utc>

Turn this DateTime into a DateTime<Utc>, dropping the offset and associated timezone information.

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.

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

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.

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

pub fn checked_add_days(self, days: Days) -> Option<Self>

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

pub fn checked_sub_days(self, days: Days) -> Option<Self>

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

pub fn signed_duration_since<Tz2: TimeZone>( self, rhs: impl Borrow<DateTime<Tz2>>, ) -> TimeDelta

Subtracts another DateTime from the current date and time. This does not overflow or underflow at all.

pub const fn naive_utc(&self) -> NaiveDateTime

Returns a view to the naive UTC datetime.

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.

pub fn years_since(&self, base: Self) -> Option<u32>

Retrieve the elapsed years from now to the given DateTime.

Errors

Returns None if base < self.

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.

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.

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");

pub fn with_time(&self, time: NaiveTime) -> LocalResult<Self>

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

pub const MIN_UTC: DateTime<Utc> = _

The minimum possible DateTime<Utc>.

pub const MAX_UTC: DateTime<Utc> = _

The maximum possible DateTime<Utc>.

impl DateTime<Utc>

pub const fn from_timestamp(secs: i64, nsecs: u32) -> Option<Self>

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

pub const fn from_timestamp_millis(millis: i64) -> Option<Self>

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

pub const fn from_timestamp_micros(micros: i64) -> Option<Self>

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());

pub const fn from_timestamp_nanos(nanos: i64) -> Self

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());

pub const UNIX_EPOCH: Self = _

The Unix Epoch, 1970-01-01 00:00:00 UTC.

impl DateTime<FixedOffset>

pub fn parse_from_rfc2822(s: &str) -> ParseResult<DateTime<FixedOffset>>

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 is Z, 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()
);

pub fn parse_from_rfc3339(s: &str) -> ParseResult<DateTime<FixedOffset>>

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

pub fn parse_from_str(s: &str, fmt: &str) -> ParseResult<DateTime<FixedOffset>>

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())
);

pub fn parse_and_remainder<'a>( s: &'a str, fmt: &str, ) -> ParseResult<(DateTime<FixedOffset>, &'a str)>

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");

impl<Tz: TimeZone> DateTime<Tz>

where Tz::Offset: Display,

pub fn format_with_items<'a, I, B>(&self, items: I) -> DelayedFormat<I>

where I: Iterator<Item = B> + Clone, B: Borrow<Item<'a>>,

Formats the combined date and time with the specified formatting items.

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

impl<Tz: TimeZone> Add<Days> for DateTime<Tz>

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.

type Output = DateTime<Tz>

The resulting type after applying the + operator.

fn add(self, days: Days) -> Self::Output

Performs the + operation.

impl<Tz: TimeZone> Add<Duration> for DateTime<Tz>

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.

type Output = DateTime<Tz>

The resulting type after applying the + operator.

fn add(self, rhs: Duration) -> DateTime<Tz>

Performs the + operation.

impl<Tz: TimeZone> Add<FixedOffset> for DateTime<Tz>

Add FixedOffset to the datetime value of DateTime (offset remains unchanged).

Panics

Panics if the resulting date would be out of range.

type Output = DateTime<Tz>

The resulting type after applying the + operator.

fn add(self, rhs: FixedOffset) -> DateTime<Tz>

Performs the + operation.

impl<Tz: TimeZone> Add<Months> for DateTime<Tz>

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.

type Output = DateTime<Tz>

The resulting type after applying the + operator.

fn add(self, rhs: Months) -> Self::Output

Performs the + operation.

impl<Tz: TimeZone> Add<TimeDelta> for DateTime<Tz>

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.

type Output = DateTime<Tz>

The resulting type after applying the + operator.

fn add(self, rhs: TimeDelta) -> DateTime<Tz>

Performs the + operation.

impl<Tz: TimeZone> AddAssign<Duration> for DateTime<Tz>

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.

fn add_assign(&mut self, rhs: Duration)

Performs the += operation.

impl<Tz: TimeZone> AddAssign<TimeDelta> for DateTime<Tz>

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.

fn add_assign(&mut self, rhs: TimeDelta)

Performs the += operation.

impl<Tz: Clone + TimeZone> Clone for DateTime<Tz>

where Tz::Offset: Clone,

fn clone(&self) -> DateTime<Tz>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<Tz: TimeZone> Datelike for 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).

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.

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.

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.

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.

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.

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.

fn year(&self) -> i32

Returns the year number in the calendar date.

fn month(&self) -> u32

Returns the month number starting from 1.

fn month0(&self) -> u32

Returns the month number starting from 0.

fn day(&self) -> u32

Returns the day of month starting from 1.

fn day0(&self) -> u32

Returns the day of month starting from 0.

fn ordinal(&self) -> u32

Returns the day of year starting from 1.

fn ordinal0(&self) -> u32

Returns the day of year starting from 0.

fn weekday(&self) -> Weekday

Returns the day of week.

fn iso_week(&self) -> IsoWeek

Returns the ISO week.

fn year_ce(&self) -> (bool, u32)

Returns the absolute year number starting from 1 with a boolean flag, which is false when the year predates the epoch (BCE/BC) and true otherwise (CE/AD).

fn num_days_from_ce(&self) -> i32

Counts the days in the proleptic Gregorian calendar, with January 1, Year 1 (CE) as day 1.

impl<Tz: TimeZone> Debug for DateTime<Tz>

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

Formats the value using the given formatter.

impl Default for DateTime<FixedOffset>

fn default() -> Self

Returns the “default value” for a type.

impl Default for DateTime<Local>

fn default() -> Self

Returns the “default value” for a type.

impl Default for DateTime<Utc>

fn default() -> Self

Returns the “default value” for a type.

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 DateTimes outside the range of 0-9999 years using an ISO 8601 syntax (which prepends an - or +).

See the serde module for alternate deserialization formats.

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

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

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 DateTimes outside the range of 0-9999 years using an ISO 8601 syntax (which prepends an - or +).

See the serde module for alternate deserialization formats.

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

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

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 DateTimes outside the range of 0-9999 years using an ISO 8601 syntax (which prepends an - or +).

See the serde module for alternate deserialization formats.

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

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<Tz: TimeZone> Display for DateTime<Tz>

where Tz::Offset: Display,

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

Formats the value using the given formatter.

impl<Tz: TimeZone> DurationRound for DateTime<Tz>

type Err = RoundingError

Error that can occur in rounding or truncating

fn duration_round(self, duration: TimeDelta) -> Result<Self, Self::Err>

Return a copy rounded by TimeDelta.

fn duration_trunc(self, duration: TimeDelta) -> Result<Self, Self::Err>

Return a copy truncated by TimeDelta.

impl From<DateTime<FixedOffset>> for DateTime<Local>

Convert a DateTime<FixedOffset> instance into a DateTime<Local> instance.

fn from(src: DateTime<FixedOffset>) -> Self

Convert this DateTime<FixedOffset> instance into a DateTime<Local> instance.

Conversion is performed via DateTime::with_timezone. Returns the equivalent value in local time.

impl From<DateTime<FixedOffset>> for DateTime<Utc>

Convert a DateTime<FixedOffset> instance into a DateTime<Utc> instance.

fn from(src: DateTime<FixedOffset>) -> Self

Convert this DateTime<FixedOffset> instance into a DateTime<Utc> instance.

Conversion is performed via DateTime::with_timezone, accounting for the timezone difference.

impl From<DateTime<Local>> for DateTime<FixedOffset>

Convert a DateTime<Local> instance into a DateTime<FixedOffset> instance.

fn from(src: DateTime<Local>) -> Self

Convert this DateTime<Local> instance into a DateTime<FixedOffset> instance.

Conversion is performed via DateTime::with_timezone.

impl From<DateTime<Local>> for DateTime<Utc>

Convert a DateTime<Local> instance into a DateTime<Utc> instance.

fn from(src: DateTime<Local>) -> Self

Convert this DateTime<Local> instance into a DateTime<Utc> instance.

Conversion is performed via DateTime::with_timezone, accounting for the difference in timezones.

impl<Tz: TimeZone> From<DateTime<Tz>> for SystemTime

fn from(dt: DateTime<Tz>) -> SystemTime

Converts to this type from the input type.

impl From<DateTime<Utc>> for DateTime<FixedOffset>

Convert a DateTime<Utc> instance into a DateTime<FixedOffset> instance.

fn from(src: DateTime<Utc>) -> Self

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.

impl From<DateTime<Utc>> for DateTime<Local>

Convert a DateTime<Utc> instance into a DateTime<Local> instance.

fn from(src: DateTime<Utc>) -> Self

Convert this DateTime<Utc> instance into a DateTime<Local> instance.

Conversion is performed via DateTime::with_timezone, accounting for the difference in timezones.

impl From<SystemTime> for DateTime<Local>

fn from(t: SystemTime) -> DateTime<Local>

Converts to this type from the input type.

impl From<SystemTime> for DateTime<Utc>

fn from(t: SystemTime) -> DateTime<Utc>

Converts to this type from the input type.

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

The associated error which can be returned from parsing.

fn from_str(s: &str) -> ParseResult<DateTime<FixedOffset>>

Parses a string s to return a value of this type.

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>>()?;

type Err = ParseError

The associated error which can be returned from parsing.

fn from_str(s: &str) -> ParseResult<DateTime<Local>>

Parses a string s to return a value of this type.

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>>()?;

type Err = ParseError

The associated error which can be returned from parsing.

fn from_str(s: &str) -> ParseResult<DateTime<Utc>>

Parses a string s to return a value of this type.

impl<Tz: TimeZone> Hash for DateTime<Tz>

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

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<Tz: TimeZone> Ord for DateTime<Tz>

fn cmp(&self, other: &DateTime<Tz>) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized + PartialOrd,

Restrict a value to a certain interval.

impl<Tz: TimeZone, Tz2: TimeZone> PartialEq<DateTime<Tz2>> for DateTime<Tz>

fn eq(&self, other: &DateTime<Tz2>) -> bool

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<Tz: TimeZone, Tz2: TimeZone> PartialOrd<DateTime<Tz2>> for DateTime<Tz>

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

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl<Tz: TimeZone> Serialize for DateTime<Tz>

Serialize to an RFC 3339 formatted string

As an extension to RFC 3339 this can serialize DateTimes outside the range of 0-9999 years using an ISO 8601 syntax (which prepends an - or +).

See the serde module for alternate serializations.

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

where S: Serializer,

Serialize this value into the given Serde serializer.

impl<Tz: TimeZone> Sub<&DateTime<Tz>> for DateTime<Tz>

type Output = TimeDelta

The resulting type after applying the - operator.

fn sub(self, rhs: &DateTime<Tz>) -> TimeDelta

Performs the - operation.

impl<Tz: TimeZone> Sub<Days> for DateTime<Tz>

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.

type Output = DateTime<Tz>

The resulting type after applying the - operator.

fn sub(self, days: Days) -> Self::Output

Performs the - operation.

impl<Tz: TimeZone> Sub<Duration> for DateTime<Tz>

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.

type Output = DateTime<Tz>

The resulting type after applying the - operator.

fn sub(self, rhs: Duration) -> DateTime<Tz>

Performs the - operation.

impl<Tz: TimeZone> Sub<FixedOffset> for DateTime<Tz>

Subtract FixedOffset from the datetime value of DateTime (offset remains unchanged).

Panics

Panics if the resulting date would be out of range.

type Output = DateTime<Tz>

The resulting type after applying the - operator.

fn sub(self, rhs: FixedOffset) -> DateTime<Tz>

Performs the - operation.

impl<Tz: TimeZone> Sub<Months> for DateTime<Tz>

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.

type Output = DateTime<Tz>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<Tz: TimeZone> Sub<TimeDelta> for DateTime<Tz>

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.

type Output = DateTime<Tz>

The resulting type after applying the - operator.

fn sub(self, rhs: TimeDelta) -> DateTime<Tz>

Performs the - operation.

impl<Tz: TimeZone> Sub for DateTime<Tz>

type Output = TimeDelta

The resulting type after applying the - operator.

fn sub(self, rhs: DateTime<Tz>) -> TimeDelta

Performs the - operation.

impl<Tz: TimeZone> SubAssign<Duration> for DateTime<Tz>

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.

fn sub_assign(&mut self, rhs: Duration)

Performs the -= operation.

impl<Tz: TimeZone> SubAssign<TimeDelta> for DateTime<Tz>

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.

fn sub_assign(&mut self, rhs: TimeDelta)

Performs the -= operation.

impl<Tz: TimeZone> Timelike for 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.

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.

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.

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.

fn hour(&self) -> u32

Returns the hour number from 0 to 23.

fn minute(&self) -> u32

Returns the minute number from 0 to 59.

fn second(&self) -> u32

Returns the second number from 0 to 59.

fn nanosecond(&self) -> u32

Returns the number of nanoseconds since the whole non-leap second. The range from 1,000,000,000 to 1,999,999,999 represents the leap second.

fn hour12(&self) -> (bool, u32)

Returns the hour number from 1 to 12 with a boolean flag, which is false for AM and true for PM.

fn num_seconds_from_midnight(&self) -> u32

Returns the number of non-leap seconds past the last midnight.

impl<Tz: TimeZone> Copy for DateTime<Tz>

where <Tz as TimeZone>::Offset: Copy, NaiveDateTime: Copy,

impl<Tz: TimeZone> Eq for DateTime<Tz>