Struct chord_core::action::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
sourceimpl<Tz> DateTime<Tz>where
Tz: TimeZone,
impl<Tz> DateTime<Tz>where
Tz: TimeZone,
sourcepub fn from_utc(
datetime: NaiveDateTime,
offset: <Tz as TimeZone>::Offset
) -> DateTime<Tz>
pub fn from_utc(
datetime: NaiveDateTime,
offset: <Tz as TimeZone>::Offset
) -> DateTime<Tz>
Makes a new DateTime
with given UTC datetime and offset.
The local datetime should be constructed via the TimeZone
trait.
Example
use chrono::{DateTime, TimeZone, NaiveDateTime, Utc};
let dt = DateTime::<Utc>::from_utc(NaiveDateTime::from_timestamp(61, 0), Utc);
assert_eq!(Utc.timestamp(61, 0), dt);
sourcepub fn from_local(
datetime: NaiveDateTime,
offset: <Tz as TimeZone>::Offset
) -> DateTime<Tz>
pub fn from_local(
datetime: NaiveDateTime,
offset: <Tz as TimeZone>::Offset
) -> DateTime<Tz>
Makes a new DateTime
with given local datetime and offset that
presents local timezone.
Example
use chrono::DateTime;
use chrono::naive::NaiveDate;
use chrono::offset::{Utc, FixedOffset};
let naivedatetime_utc = NaiveDate::from_ymd(2000, 1, 12).and_hms(2, 0, 0);
let datetime_utc = DateTime::<Utc>::from_utc(naivedatetime_utc, Utc);
let timezone_east = FixedOffset::east(8 * 60 * 60);
let naivedatetime_east = NaiveDate::from_ymd(2000, 1, 12).and_hms(10, 0, 0);
let datetime_east = DateTime::<FixedOffset>::from_local(naivedatetime_east, timezone_east);
let timezone_west = FixedOffset::west(7 * 60 * 60);
let naivedatetime_west = NaiveDate::from_ymd(2000, 1, 11).and_hms(19, 0, 0);
let datetime_west = DateTime::<FixedOffset>::from_local(naivedatetime_west, timezone_west);
assert_eq!(datetime_east, datetime_utc.with_timezone(&timezone_east));
assert_eq!(datetime_west, datetime_utc.with_timezone(&timezone_west));
sourcepub fn date(&self) -> Date<Tz>
pub fn date(&self) -> Date<Tz>
Retrieves a date component
Unless you are immediately planning on turning this into a DateTime
with the same Timezone you should use the
date_naive
method.
use chrono::prelude::*;
let date: Date<Utc> = Utc.ymd(2020, 1, 1);
let dt: DateTime<Utc> = date.and_hms(0, 0, 0);
assert_eq!(dt.date(), date);
assert_eq!(dt.date().and_hms(1, 1, 1), date.and_hms(1, 1, 1));
sourcepub fn date_naive(&self) -> NaiveDate
pub fn date_naive(&self) -> NaiveDate
Retrieves the Date without an associated timezone
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.
use chrono::prelude::*;
let date: DateTime<Utc> = Utc.ymd(2020, 1, 1).and_hms(0, 0, 0);
let other: DateTime<FixedOffset> = FixedOffset::east(23).ymd(2020, 1, 1).and_hms(0, 0, 0);
assert_eq!(date.date_naive(), other.date_naive());
sourcepub fn time(&self) -> NaiveTime
pub fn time(&self) -> NaiveTime
Retrieves a time component.
Unlike date
, this is not associated to the time zone.
sourcepub fn timestamp(&self) -> i64
pub fn timestamp(&self) -> i64
Returns the number of non-leap seconds since January 1, 1970 0:00:00 UTC (aka “UNIX timestamp”).
sourcepub fn timestamp_millis(&self) -> i64
pub fn timestamp_millis(&self) -> i64
Returns the number of non-leap-milliseconds since January 1, 1970 UTC
Note that this does reduce the number of years that can be represented from ~584 Billion to ~584 Million. (If this is a problem, please file an issue to let me know what domain needs millisecond precision over billions of years, I’m curious.)
Example
use chrono::Utc;
use chrono::TimeZone;
let dt = Utc.ymd(1970, 1, 1).and_hms_milli(0, 0, 1, 444);
assert_eq!(dt.timestamp_millis(), 1_444);
let dt = Utc.ymd(2001, 9, 9).and_hms_milli(1, 46, 40, 555);
assert_eq!(dt.timestamp_millis(), 1_000_000_000_555);
sourcepub fn timestamp_micros(&self) -> i64
pub fn timestamp_micros(&self) -> i64
Returns the number of non-leap-microseconds since January 1, 1970 UTC
Note that this does reduce the number of years that can be represented from ~584 Billion to ~584 Thousand. (If this is a problem, please file an issue to let me know what domain needs microsecond precision over millennia, I’m curious.)
Example
use chrono::Utc;
use chrono::TimeZone;
let dt = Utc.ymd(1970, 1, 1).and_hms_micro(0, 0, 1, 444);
assert_eq!(dt.timestamp_micros(), 1_000_444);
let dt = Utc.ymd(2001, 9, 9).and_hms_micro(1, 46, 40, 555);
assert_eq!(dt.timestamp_micros(), 1_000_000_000_000_555);
sourcepub fn timestamp_nanos(&self) -> i64
pub fn timestamp_nanos(&self) -> i64
Returns the number of non-leap-nanoseconds since January 1, 1970 UTC
Note that this does reduce the number of years that can be represented from ~584 Billion to ~584. (If this is a problem, please file an issue to let me know what domain needs nanosecond precision over millennia, I’m curious.)
Example
use chrono::Utc;
use chrono::TimeZone;
let dt = Utc.ymd(1970, 1, 1).and_hms_nano(0, 0, 1, 444);
assert_eq!(dt.timestamp_nanos(), 1_000_000_444);
let dt = Utc.ymd(2001, 9, 9).and_hms_nano(1, 46, 40, 555);
assert_eq!(dt.timestamp_nanos(), 1_000_000_000_000_000_555);
sourcepub fn timestamp_subsec_millis(&self) -> u32
pub fn timestamp_subsec_millis(&self) -> u32
Returns the number of milliseconds since the last second boundary
warning: in event of a leap second, this may exceed 999
note: this is not the number of milliseconds since January 1, 1970 0:00:00 UTC
sourcepub fn timestamp_subsec_micros(&self) -> u32
pub fn timestamp_subsec_micros(&self) -> u32
Returns the number of microseconds since the last second boundary
warning: in event of a leap second, this may exceed 999_999
note: this is not the number of microseconds since January 1, 1970 0:00:00 UTC
sourcepub fn timestamp_subsec_nanos(&self) -> u32
pub fn timestamp_subsec_nanos(&self) -> u32
Returns the number of nanoseconds since the last second boundary
warning: in event of a leap second, this may exceed 999_999_999
note: this is not the number of nanoseconds since January 1, 1970 0:00:00 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 checked_add_signed(self, rhs: Duration) -> Option<DateTime<Tz>>
pub fn checked_add_signed(self, rhs: Duration) -> Option<DateTime<Tz>>
Adds given Duration
to the current date and time.
Returns None
when it will result in overflow.
sourcepub fn checked_sub_signed(self, rhs: Duration) -> Option<DateTime<Tz>>
pub fn checked_sub_signed(self, rhs: Duration) -> Option<DateTime<Tz>>
Subtracts given Duration
from the current date and time.
Returns None
when it will result in overflow.
sourcepub fn signed_duration_since<Tz2>(self, rhs: DateTime<Tz2>) -> Durationwhere
Tz2: TimeZone,
pub fn signed_duration_since<Tz2>(self, rhs: DateTime<Tz2>) -> Durationwhere
Tz2: TimeZone,
Subtracts another DateTime
from the current date and time.
This does not overflow or underflow at all.
sourcepub fn naive_utc(&self) -> NaiveDateTime
pub 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.
sourcepub fn years_since(&self, base: DateTime<Tz>) -> Option<u32>
pub fn years_since(&self, base: DateTime<Tz>) -> Option<u32>
Retrieve the elapsed years from now to the given DateTime
.
sourceimpl 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 such as Tue, 1 Jul 2003 10:52:37 +0200
,
then returns a new DateTime
with a parsed FixedOffset
.
RFC 2822 is the internet message standard that specifies the representation of times in HTTP and email headers.
assert_eq!(
DateTime::parse_from_rfc2822("Wed, 18 Feb 2015 23:16:09 GMT").unwrap(),
FixedOffset::east(0).ymd(2015, 2, 18).and_hms(23, 16, 9)
);
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 and ISO 8601 date and time string such as 1996-12-19T16:39:57-08:00
,
then returns a new DateTime
with a parsed FixedOffset
.
Why isn’t this named parse_from_iso8601
? That’s because ISO 8601 allows some freedom
over the syntax and RFC 3339 exercises that freedom to rigidly define a fixed format.
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 with the specified format string and returns a new
DateTime
with a parsed FixedOffset
.
See the crate::format::strftime
module on the supported escape
sequences.
See also TimeZone::datetime_from_str
which gives a local
DateTime
on specific time zone.
Note that this method requires a timezone in the string. See
NaiveDateTime::parse_from_str
for a version that does not require a timezone in the to-be-parsed str.
Example
use chrono::{DateTime, FixedOffset, 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(0).ymd(1983, 4, 13).and_hms_milli(12, 9, 14, 274)));
sourceimpl<Tz> DateTime<Tz>where
Tz: TimeZone,
<Tz as TimeZone>::Offset: Display,
impl<Tz> DateTime<Tz>where
Tz: TimeZone,
<Tz as TimeZone>::Offset: Display,
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
.
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 a SecondsFormat
.
If passed use_z
true and the timezone is UTC (offset 0), use ‘Z’, as
per Fixed::TimezoneOffsetColonZ
If passed use_z
false, use
Fixed::TimezoneOffsetColon
Examples
let dt = Utc.ymd(2018, 1, 26).and_hms_micro(18, 30, 9, 453_829);
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(8 * 60 * 60);
let dt = pst.ymd(2018, 1, 26).and_hms_micro(10, 30, 9, 453_829);
assert_eq!(dt.to_rfc3339_opts(SecondsFormat::Secs, true),
"2018-01-26T10:30:09+08:00");
sourcepub fn format_with_items<'a, I, B>(&self, items: I) -> DelayedFormat<I>where
I: Iterator<Item = B> + Clone,
B: Borrow<Item<'a>>,
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.
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 with the specified format string.
See the crate::format::strftime
module
on the supported escape sequences.
Example
use chrono::prelude::*;
let date_time: DateTime<Utc> = Utc.ymd(2017, 04, 02).and_hms(12, 50, 32);
let formatted = format!("{}", date_time.format("%d/%m/%Y %H:%M"));
assert_eq!(formatted, "02/04/2017 12:50");
Trait Implementations
sourceimpl<Tz> Add<FixedOffset> for DateTime<Tz>where
Tz: TimeZone,
impl<Tz> Add<FixedOffset> for DateTime<Tz>where
Tz: TimeZone,
sourceimpl<Tz> AddAssign<Duration> for DateTime<Tz>where
Tz: TimeZone,
impl<Tz> AddAssign<Duration> for DateTime<Tz>where
Tz: TimeZone,
sourcefn add_assign(&mut self, rhs: Duration)
fn add_assign(&mut self, rhs: Duration)
+=
operation. Read moresourceimpl<Tz> Datelike for DateTime<Tz>where
Tz: TimeZone,
impl<Tz> Datelike for DateTime<Tz>where
Tz: TimeZone,
sourcefn year(&self) -> i32
fn year(&self) -> i32
sourcefn with_year(&self, year: i32) -> Option<DateTime<Tz>>
fn with_year(&self, year: i32) -> Option<DateTime<Tz>>
sourcefn with_month(&self, month: u32) -> Option<DateTime<Tz>>
fn with_month(&self, month: u32) -> Option<DateTime<Tz>>
sourcefn with_month0(&self, month0: u32) -> Option<DateTime<Tz>>
fn with_month0(&self, month0: u32) -> Option<DateTime<Tz>>
sourcefn with_day(&self, day: u32) -> Option<DateTime<Tz>>
fn with_day(&self, day: u32) -> Option<DateTime<Tz>>
sourcefn with_day0(&self, day0: u32) -> Option<DateTime<Tz>>
fn with_day0(&self, day0: u32) -> Option<DateTime<Tz>>
sourcefn with_ordinal(&self, ordinal: u32) -> Option<DateTime<Tz>>
fn with_ordinal(&self, ordinal: u32) -> Option<DateTime<Tz>>
sourcefn with_ordinal0(&self, ordinal0: u32) -> Option<DateTime<Tz>>
fn with_ordinal0(&self, ordinal0: u32) -> Option<DateTime<Tz>>
sourcefn year_ce(&self) -> (bool, u32)
fn year_ce(&self) -> (bool, u32)
sourcefn num_days_from_ce(&self) -> i32
fn num_days_from_ce(&self) -> i32
sourceimpl Default for DateTime<FixedOffset>
impl Default for DateTime<FixedOffset>
sourcefn default() -> DateTime<FixedOffset>
fn default() -> DateTime<FixedOffset>
sourceimpl<'de> Deserialize<'de> for DateTime<FixedOffset>
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.
sourcefn 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>,
sourceimpl<'de> Deserialize<'de> for DateTime<Local>
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.
sourcefn 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>,
sourceimpl<'de> Deserialize<'de> for DateTime<Utc>
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.
sourcefn 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>,
sourceimpl<Tz> DurationRound for DateTime<Tz>where
Tz: TimeZone,
impl<Tz> DurationRound for DateTime<Tz>where
Tz: TimeZone,
type Err = RoundingError
type Err = RoundingError
sourcefn duration_round(
self,
duration: Duration
) -> Result<DateTime<Tz>, <DateTime<Tz> as DurationRound>::Err>
fn duration_round(
self,
duration: Duration
) -> Result<DateTime<Tz>, <DateTime<Tz> as DurationRound>::Err>
sourcefn duration_trunc(
self,
duration: Duration
) -> Result<DateTime<Tz>, <DateTime<Tz> as DurationRound>::Err>
fn duration_trunc(
self,
duration: Duration
) -> Result<DateTime<Tz>, <DateTime<Tz> as DurationRound>::Err>
sourceimpl From<DateTime<FixedOffset>> for DateTime<Local>
impl From<DateTime<FixedOffset>> for DateTime<Local>
Convert a DateTime<FixedOffset>
instance into a DateTime<Local>
instance.
sourcefn 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.
sourceimpl From<DateTime<FixedOffset>> for DateTime<Utc>
impl From<DateTime<FixedOffset>> for DateTime<Utc>
Convert a DateTime<FixedOffset>
instance into a DateTime<Utc>
instance.
sourcefn 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.
sourceimpl From<DateTime<Local>> for DateTime<FixedOffset>
impl From<DateTime<Local>> for DateTime<FixedOffset>
Convert a DateTime<Local>
instance into a DateTime<FixedOffset>
instance.
sourcefn 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
. Note that the converted value returned
by this will be created with a fixed timezone offset of 0.
sourceimpl From<DateTime<Local>> for DateTime<Utc>
impl From<DateTime<Local>> for DateTime<Utc>
Convert a DateTime<Local>
instance into a DateTime<Utc>
instance.
sourceimpl From<DateTime<Utc>> for DateTime<FixedOffset>
impl From<DateTime<Utc>> for DateTime<FixedOffset>
Convert a DateTime<Utc>
instance into a DateTime<FixedOffset>
instance.
sourcefn 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.
sourceimpl From<DateTime<Utc>> for DateTime<Local>
impl From<DateTime<Utc>> for DateTime<Local>
Convert a DateTime<Utc>
instance into a DateTime<Local>
instance.
sourceimpl From<SystemTime> for DateTime<Local>
impl From<SystemTime> for DateTime<Local>
sourcefn from(t: SystemTime) -> DateTime<Local>
fn from(t: SystemTime) -> DateTime<Local>
sourceimpl From<SystemTime> for DateTime<Utc>
impl From<SystemTime> for DateTime<Utc>
sourcefn from(t: SystemTime) -> DateTime<Utc>
fn from(t: SystemTime) -> DateTime<Utc>
sourceimpl 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
sourcefn 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 moresourceimpl FromStr for DateTime<Local>
impl FromStr for DateTime<Local>
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<Local>>();
"2012-12-12 12:12:12Z".parse::<DateTime<Local>>();
"2012- 12-12T12: 12:12Z".parse::<DateTime<Local>>();
type Err = ParseError
type Err = ParseError
sourceimpl FromStr for DateTime<Utc>
impl FromStr for DateTime<Utc>
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<Utc>>();
"2012-12-12 12:12:12Z".parse::<DateTime<Utc>>();
"2012- 12-12T12: 12:12Z".parse::<DateTime<Utc>>();
type Err = ParseError
type Err = ParseError
sourceimpl<Tz> Ord for DateTime<Tz>where
Tz: TimeZone,
impl<Tz> Ord for DateTime<Tz>where
Tz: TimeZone,
1.21.0 · sourcefn max(self, other: Self) -> Selfwhere
Self: Sized,
fn max(self, other: Self) -> Selfwhere
Self: Sized,
1.21.0 · sourcefn min(self, other: Self) -> Selfwhere
Self: Sized,
fn min(self, other: Self) -> Selfwhere
Self: Sized,
1.50.0 · sourcefn clamp(self, min: Self, max: Self) -> Selfwhere
Self: Sized + PartialOrd<Self>,
fn clamp(self, min: Self, max: Self) -> Selfwhere
Self: Sized + PartialOrd<Self>,
sourceimpl<Tz, Tz2> PartialEq<DateTime<Tz2>> for DateTime<Tz>where
Tz: TimeZone,
Tz2: TimeZone,
impl<Tz, Tz2> PartialEq<DateTime<Tz2>> for DateTime<Tz>where
Tz: TimeZone,
Tz2: TimeZone,
sourceimpl<Tz, Tz2> PartialOrd<DateTime<Tz2>> for DateTime<Tz>where
Tz: TimeZone,
Tz2: TimeZone,
impl<Tz, Tz2> PartialOrd<DateTime<Tz2>> for DateTime<Tz>where
Tz: TimeZone,
Tz2: TimeZone,
sourcefn 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.ymd(2015, 5, 15).and_hms(2, 0, 0).with_timezone(&FixedOffset::west(1 * 3600));
let later = Utc.ymd(2015, 5, 15).and_hms(3, 0, 0).with_timezone(&FixedOffset::west(5 * 3600));
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 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
self
and other
) and is used by the <=
operator. Read moresourceimpl<Tz> Serialize for DateTime<Tz>where
Tz: TimeZone,
impl<Tz> Serialize for DateTime<Tz>where
Tz: TimeZone,
Serialize into a rfc3339 time string
See the serde
module for alternate
serializations.
sourcefn 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,
sourceimpl<Tz> Sub<FixedOffset> for DateTime<Tz>where
Tz: TimeZone,
impl<Tz> Sub<FixedOffset> for DateTime<Tz>where
Tz: TimeZone,
sourceimpl<Tz> SubAssign<Duration> for DateTime<Tz>where
Tz: TimeZone,
impl<Tz> SubAssign<Duration> for DateTime<Tz>where
Tz: TimeZone,
sourcefn sub_assign(&mut self, rhs: Duration)
fn sub_assign(&mut self, rhs: Duration)
-=
operation. Read more