Struct tea_sdk::vmh::utils::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,

source

pub 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::{Local, DateTime};

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

pub 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

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

source

pub 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

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.

source

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.

source

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

pub fn time(&self) -> NaiveTime

Retrieves the time component.

source

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

pub fn timestamp_millis(&self) -> i64

Returns the number of non-leap-milliseconds since January 1, 1970 UTC.

Example
use chrono::{Utc, NaiveDate};

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

pub fn timestamp_micros(&self) -> i64

Returns the number of non-leap-microseconds since January 1, 1970 UTC.

Example
use chrono::{Utc, NaiveDate};

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

pub 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:44.0 and 2262-04-11T23:47:16.854775804.

source

pub fn timestamp_nanos_opt(&self) -> Option<i64>

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:44.0 and 2262-04-11T23:47:16.854775804.

Example
use chrono::{Utc, NaiveDate};

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

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

source

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

source

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

source

pub fn offset(&self) -> &<Tz as TimeZone>::Offset

Retrieves an associated offset from UTC.

source

pub fn timezone(&self) -> Tz

Retrieves an associated time zone.

source

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.

source

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

source

pub fn checked_add_signed(self, rhs: Duration) -> Option<DateTime<Tz>>

Adds given Duration to the current date and time.

Errors

Returns None if the resulting date would be out of range.

source

pub fn checked_add_months(self, rhs: 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 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.
source

pub fn checked_sub_signed(self, rhs: Duration) -> Option<DateTime<Tz>>

Subtracts given Duration from the current date and time.

Errors

Returns None if the resulting date would be out of range.

source

pub fn checked_sub_months(self, rhs: 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 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.
source

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

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

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

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

source

pub fn naive_utc(&self) -> NaiveDateTime

Returns a view to the naive UTC datetime.

source

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.

source

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

Retrieve the elapsed years from now to the given DateTime.

Errors

Returns None if base < self.

source

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.

source

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.

source

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_local_timezone(Utc).unwrap();
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");
source

pub const MIN_UTC: DateTime<Utc> = _

The minimum possible DateTime<Utc>.

source

pub const MAX_UTC: DateTime<Utc> = _

The maximum possible DateTime<Utc>.

source§

impl DateTime<Utc>

source

pub 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, Utc};

let dt: DateTime<Utc> = DateTime::<Utc>::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);
source

pub const UNIX_EPOCH: DateTime<Utc> = _

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

source§

impl DateTime<FixedOffset>

source

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

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

source

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, TimeZone, NaiveDate};

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

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>where Tz: TimeZone, <Tz as TimeZone>::Offset: Display,

source

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.

source

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,

§

type Output = DateTime<Tz>

The resulting type after applying the + operator.
source§

fn add(self, days: Days) -> <DateTime<Tz> as Add<Days>>::Output

Performs the + operation. Read more
source§

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

§

type Output = DateTime<Tz>

The resulting type after applying the + operator.
source§

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

Performs the + operation. Read more
source§

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

§

type Output = DateTime<Tz>

The resulting type after applying the + operator.
source§

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

Performs the + operation. Read more
source§

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

§

type Output = DateTime<Tz>

The resulting type after applying the + operator.
source§

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

Performs the + operation. Read more
source§

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

§

type Output = DateTime<Tz>

The resulting type after applying the + operator.
source§

fn add(self, rhs: Months) -> <DateTime<Tz> as Add<Months>>::Output

Performs the + operation. Read more
source§

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

source§

fn add_assign(&mut self, rhs: Duration)

Performs the += operation. Read more
source§

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

source§

fn add_assign(&mut self, rhs: Duration)

Performs the += operation. Read more
source§

impl<Tz> Clone for DateTime<Tz>where Tz: Clone + TimeZone, <Tz as TimeZone>::Offset: Clone,

source§

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

Returns a copy of the value. Read more
1.0.0 · source§

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

Performs copy-assignment from source. Read more
source§

impl<Tz> Datelike for DateTime<Tz>where Tz: TimeZone,

source§

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.
  • When the NaiveDateTime 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.
source§

fn with_month(&self, month: u32) -> Option<DateTime<Tz>>

Makes a new DateTime with the month number (starting from 1) changed.

See also the NaiveDate::with_month method.

Errors

Returns None if:

  • The resulting date does not exist.
  • 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>>

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

Makes a new DateTime with the month number (starting from 0) changed.

See also the NaiveDate::with_day method.

Errors

Returns None if:

  • The resulting date does not exist.
  • 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>>

Makes a new DateTime with the month number (starting from 0) changed.

See also the NaiveDate::with_day0 method.

Errors

Returns None if:

  • The resulting date does not exist.
  • 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>>

Makes a new DateTime with the month number (starting from 0) changed.

See also the NaiveDate::with_ordinal method.

Errors

Returns None if:

  • The resulting date does not exist.
  • 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>>

Makes a new DateTime with the month number (starting from 0) changed.

See also the NaiveDate::with_ordinal0 method.

Errors

Returns None if:

  • The resulting date does not exist.
  • 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

Returns the year number in the calendar date.
source§

fn month(&self) -> u32

Returns the month number starting from 1. Read more
source§

fn month0(&self) -> u32

Returns the month number starting from 0. Read more
source§

fn day(&self) -> u32

Returns the day of month starting from 1. Read more
source§

fn day0(&self) -> u32

Returns the day of month starting from 0. Read more
source§

fn ordinal(&self) -> u32

Returns the day of year starting from 1. Read more
source§

fn ordinal0(&self) -> u32

Returns the day of year starting from 0. Read more
source§

fn weekday(&self) -> Weekday

Returns the day of week.
source§

fn iso_week(&self) -> IsoWeek

Returns the ISO week.
source§

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

fn num_days_from_ce(&self) -> i32

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

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

source§

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

Formats the value using the given formatter. Read more
source§

impl Default for DateTime<FixedOffset>

source§

fn default() -> DateTime<FixedOffset>

Returns the “default value” for a type. Read more
source§

impl Default for DateTime<Local>

source§

fn default() -> DateTime<Local>

Returns the “default value” for a type. Read more
source§

impl Default for DateTime<Utc>

source§

fn default() -> DateTime<Utc>

Returns the “default value” for a type. Read more
source§

impl<'de> Deserialize<'de> for DateTime<FixedOffset>

Deserialize a value that optionally includes a timezone offset in its string representation

The value to be deserialized must be an rfc3339 string.

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

Deserialize this value from the given Serde deserializer. Read more
source§

impl<'de> Deserialize<'de> for DateTime<Local>

Deserialize a value that includes no timezone in its string representation

The value to be deserialized must be an rfc3339 string.

See the serde module for alternate serialization formats.

source§

fn deserialize<D>( deserializer: D ) -> Result<DateTime<Local>, <D as Deserializer<'de>>::Error>where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer. Read more
source§

impl<'de> Deserialize<'de> for DateTime<Utc>

Deserialize into a UTC value

The value to be deserialized must be an rfc3339 string.

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

Deserialize this value from the given Serde deserializer. Read more
source§

impl<Tz> Display for DateTime<Tz>where Tz: TimeZone, <Tz as TimeZone>::Offset: Display,

source§

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

Formats the value using the given formatter. Read more
source§

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

§

type Err = RoundingError

Error that can occur in rounding or truncating
source§

fn duration_round( self, duration: Duration ) -> Result<DateTime<Tz>, <DateTime<Tz> as DurationRound>::Err>

Return a copy rounded by Duration. Read more
source§

fn duration_trunc( self, duration: Duration ) -> Result<DateTime<Tz>, <DateTime<Tz> as DurationRound>::Err>

Return a copy truncated by Duration. Read more
source§

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>

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>

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

source§

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>

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

source§

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>

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

source§

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

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

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

source§

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>

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>

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

source§

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

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

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

source§

impl From<SystemTime> for DateTime<Local>

source§

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

Converts to this type from the input type.
source§

impl From<SystemTime> for DateTime<Utc>

source§

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

Converts to this type from the input type.
source§

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

fn from_str(s: &str) -> Result<DateTime<FixedOffset>, ParseError>

Parses a string s to return a value of this type. Read more
source§

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

fn from_str(s: &str) -> Result<DateTime<Local>, ParseError>

Parses a string s to return a value of this type. Read more
source§

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

fn from_str(s: &str) -> Result<DateTime<Utc>, ParseError>

Parses a string s to return a value of this type. Read more
source§

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

source§

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

Feeds this value into the given Hasher. Read more
1.3.0 · source§

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

Feeds a slice of this type into the given Hasher. Read more
source§

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

source§

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

This method returns an Ordering between self and other. Read more
1.21.0 · source§

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

Compares and returns the maximum of two values. Read more
1.21.0 · source§

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

Compares and returns the minimum of two values. Read more
1.50.0 · source§

fn clamp(self, min: Self, max: Self) -> Selfwhere Self: Sized + PartialOrd,

Restrict a value to a certain interval. Read more
source§

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

source§

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

This method tests for self and other values to be equal, and is used by ==.
1.0.0 · source§

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.
source§

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

source§

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 lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator. Read more
1.0.0 · source§

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

This method tests less than or equal to (for self and other) and is used by the <= operator. Read more
1.0.0 · source§

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

This method tests greater than (for self and other) and is used by the > operator. Read more
1.0.0 · source§

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

This method tests greater than or equal to (for self and other) and is used by the >= operator. Read more
source§

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

Serialize into an ISO 8601 formatted string.

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,

Serialize this value into the given Serde serializer. Read more
source§

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

§

type Output = Duration

The resulting type after applying the - operator.
source§

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

Performs the - operation. Read more
source§

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

§

type Output = DateTime<Tz>

The resulting type after applying the - operator.
source§

fn sub(self, days: Days) -> <DateTime<Tz> as Sub<Days>>::Output

Performs the - operation. Read more
source§

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

§

type Output = DateTime<Tz>

The resulting type after applying the - operator.
source§

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

Performs the - operation. Read more
source§

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

§

type Output = DateTime<Tz>

The resulting type after applying the - operator.
source§

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

Performs the - operation. Read more
source§

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

§

type Output = DateTime<Tz>

The resulting type after applying the - operator.
source§

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

Performs the - operation. Read more
source§

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

§

type Output = DateTime<Tz>

The resulting type after applying the - operator.
source§

fn sub(self, rhs: Months) -> <DateTime<Tz> as Sub<Months>>::Output

Performs the - operation. Read more
source§

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

§

type Output = Duration

The resulting type after applying the - operator.
source§

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

Performs the - operation. Read more
source§

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

source§

fn sub_assign(&mut self, rhs: Duration)

Performs the -= operation. Read more
source§

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

source§

fn sub_assign(&mut self, rhs: Duration)

Performs the -= operation. Read more
source§

impl<Tz> Timelike for DateTime<Tz>where Tz: TimeZone,

source§

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

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

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

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.

source§

fn hour(&self) -> u32

Returns the hour number from 0 to 23.
source§

fn minute(&self) -> u32

Returns the minute number from 0 to 59.
source§

fn second(&self) -> u32

Returns the second number from 0 to 59.
source§

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

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

fn num_seconds_from_midnight(&self) -> u32

Returns the number of non-leap seconds past the last midnight. Read more
source§

impl<Tz> Copy for DateTime<Tz>where Tz: TimeZone, <Tz as TimeZone>::Offset: Copy,

source§

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

source§

impl<Tz> Send for DateTime<Tz>where Tz: TimeZone, <Tz as TimeZone>::Offset: Send,

Auto Trait Implementations§

§

impl<Tz> RefUnwindSafe for DateTime<Tz>where <Tz as TimeZone>::Offset: RefUnwindSafe,

§

impl<Tz> Sync for DateTime<Tz>where <Tz as TimeZone>::Offset: Sync,

§

impl<Tz> Unpin for DateTime<Tz>where <Tz as TimeZone>::Offset: Unpin,

§

impl<Tz> UnwindSafe for DateTime<Tz>where <Tz as TimeZone>::Offset: UnwindSafe,

Blanket Implementations§

source§

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

source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
source§

impl<T> Borrow<T> for Twhere T: ?Sized,

source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
source§

impl<T> BorrowMut<T> for Twhere T: ?Sized,

source§

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

Mutably borrows from an owned value. Read more
source§

impl<Q, K> Equivalent<K> for Qwhere Q: Eq + ?Sized, K: Borrow<Q> + ?Sized,

source§

fn equivalent(&self, key: &K) -> bool

Compare self to key and return true if they are equal.
source§

impl<T> From<T> for T

source§

fn from(t: T) -> T

Returns the argument unchanged.

§

impl<'a, T> FromBytes<'a> for Twhere T: IsFromBytes<'a>,

§

default fn from_bytes(buf: &'a [u8]) -> Result<T, Global>

§

impl<T> FromHttpBytes for Twhere T: DeserializeOwned, NotBytesWrapper<T>: NotBytes,

§

default fn from_http_bytes(input: Vec<u8>) -> Result<T, RuntimeCodec>

§

impl<T> Instrument for T

§

fn instrument(self, span: Span) -> Instrumented<Self>

Instruments this type with the provided [Span], returning an Instrumented wrapper. Read more
§

fn in_current_span(self) -> Instrumented<Self>

Instruments this type with the current Span, returning an Instrumented wrapper. Read more
source§

impl<T, U> Into<U> for Twhere U: From<T>,

source§

fn into(self) -> U

Calls U::from(self).

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

§

impl<T> IntoHttpBytes for Twhere T: Serialize, NotBytesWrapper<T>: NotBytes,

§

default fn into_http_bytes(self) -> Result<Vec<u8>, RuntimeCodec>

source§

impl<T> Same for T

§

type Output = T

Should always be Self
source§

impl<T> SubsecRound for Twhere T: Add<Duration, Output = T> + Sub<Duration, Output = T> + Timelike,

source§

fn round_subsecs(self, digits: u16) -> T

Return a copy rounded to the specified number of subsecond digits. With 9 or more digits, self is returned unmodified. Halfway values are rounded up (away from zero). Read more
source§

fn trunc_subsecs(self, digits: u16) -> T

Return a copy truncated to the specified number of subsecond digits. With 9 or more digits, self is returned unmodified. Read more
§

impl<T> ToBytes for Twhere T: IsToBytes,

§

fn to_bytes(&self) -> Result<Vec<u8>, Global>

§

fn bytes_len(&self) -> Result<usize, Global>

§

fn write_to(&self, w: impl SerBuf) -> Result<(), Global>

source§

impl<T> ToOwned for Twhere T: Clone,

§

type Owned = T

The resulting type after obtaining ownership.
source§

fn to_owned(&self) -> T

Creates owned data from borrowed data, usually by cloning. Read more
source§

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

Uses borrowed data to replace owned data, usually by cloning. Read more
source§

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

source§

default fn to_string(&self) -> String

Converts the given value to a String. Read more
source§

impl<T, U> TryFrom<U> for Twhere U: Into<T>,

§

type Error = Infallible

The type returned in the event of a conversion error.
source§

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

Performs the conversion.
source§

impl<T, U> TryInto<U> for Twhere U: TryFrom<T>,

§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
source§

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

Performs the conversion.
§

impl<V, T> VZip<V> for Twhere V: MultiLane<T>,

§

fn vzip(self) -> V

§

impl<T> WithSubscriber for T

§

fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>where S: Into<Dispatch>,

Attaches the provided Subscriber to this type, returning a [WithDispatch] wrapper. Read more
§

fn with_current_subscriber(self) -> WithDispatch<Self>

Attaches the current default Subscriber to this type, returning a [WithDispatch] wrapper. Read more
source§

impl<T> DeserializeOwned for Twhere T: for<'de> Deserialize<'de>,