[go: up one dir, main page]

Struct serde_with::chrono::Duration

source · 
pub struct Duration { /* private fields */ }
Available on crate feature chrono only.
Expand description

ISO 8601 time duration with nanosecond precision.

This also allows for the negative duration; see individual methods for details.

Implementations§

source§

impl Duration

source

pub fn weeks(weeks: i64) -> Duration

Makes a new Duration with given number of weeks. Equivalent to Duration::seconds(weeks * 7 * 24 * 60 * 60) with overflow checks. Panics when the duration is out of bounds.

source

pub fn days(days: i64) -> Duration

Makes a new Duration with given number of days. Equivalent to Duration::seconds(days * 24 * 60 * 60) with overflow checks. Panics when the duration is out of bounds.

source

pub fn hours(hours: i64) -> Duration

Makes a new Duration with given number of hours. Equivalent to Duration::seconds(hours * 60 * 60) with overflow checks. Panics when the duration is out of bounds.

source

pub fn minutes(minutes: i64) -> Duration

Makes a new Duration with given number of minutes. Equivalent to Duration::seconds(minutes * 60) with overflow checks. Panics when the duration is out of bounds.

source

pub fn seconds(seconds: i64) -> Duration

Makes a new Duration with given number of seconds. Panics when the duration is more than i64::MAX seconds or less than i64::MIN seconds.

source

pub const fn milliseconds(milliseconds: i64) -> Duration

Makes a new Duration with given number of milliseconds.

source

pub const fn microseconds(microseconds: i64) -> Duration

Makes a new Duration with given number of microseconds.

source

pub const fn nanoseconds(nanos: i64) -> Duration

Makes a new Duration with given number of nanoseconds.

source

pub const fn num_weeks(&self) -> i64

Returns the total number of whole weeks in the duration.

source

pub const fn num_days(&self) -> i64

Returns the total number of whole days in the duration.

source

pub const fn num_hours(&self) -> i64

Returns the total number of whole hours in the duration.

source

pub const fn num_minutes(&self) -> i64

Returns the total number of whole minutes in the duration.

source

pub const fn num_seconds(&self) -> i64

Returns the total number of whole seconds in the duration.

source

pub const fn num_milliseconds(&self) -> i64

Returns the total number of whole milliseconds in the duration,

source

pub const fn num_microseconds(&self) -> Option<i64>

Returns the total number of whole microseconds in the duration, or None on overflow (exceeding 2^63 microseconds in either direction).

source

pub const fn num_nanoseconds(&self) -> Option<i64>

Returns the total number of whole nanoseconds in the duration, or None on overflow (exceeding 2^63 nanoseconds in either direction).

source

pub fn checked_add(&self, rhs: &Duration) -> Option<Duration>

Add two durations, returning None if overflow occurred.

source

pub fn checked_sub(&self, rhs: &Duration) -> Option<Duration>

Subtract two durations, returning None if overflow occurred.

source

pub const fn abs(&self) -> Duration

Returns the duration as an absolute (non-negative) value.

source

pub const fn min_value() -> Duration

The minimum possible Duration: i64::MIN milliseconds.

source

pub const fn max_value() -> Duration

The maximum possible Duration: i64::MAX milliseconds.

source

pub const fn zero() -> Duration

A duration where the stored seconds and nanoseconds are equal to zero.

source

pub const fn is_zero(&self) -> bool

Returns true if the duration equals Duration::zero().

source

pub fn from_std(duration: Duration) -> Result<Duration, OutOfRangeError>

Creates a time::Duration object from std::time::Duration

This function errors when original duration is larger than the maximum value supported for this type.

source

pub fn to_std(&self) -> Result<Duration, OutOfRangeError>

Creates a std::time::Duration object from time::Duration

This function errors when duration is less than zero. As standard library implementation is limited to non-negative values.

Trait Implementations§

source§

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

§

type Output = Date<Tz>

The resulting type after applying the + operator.
source§

fn add(self, rhs: Duration) -> Date<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 Add<Duration> for Duration

§

type Output = Duration

The resulting type after applying the + operator.
source§

fn add(self, rhs: Duration) -> Duration

Performs the + operation. Read more
source§

impl Add<Duration> for NaiveDate

An addition of Duration to NaiveDate discards the fractional days, rounding to the closest integral number of days towards Duration::zero().

Panics on underflow or overflow. Use NaiveDate::checked_add_signed to detect that.

Example

use chrono::{Duration, NaiveDate};

let from_ymd = |y, m, d| NaiveDate::from_ymd_opt(y, m, d).unwrap();

assert_eq!(from_ymd(2014, 1, 1) + Duration::zero(),             from_ymd(2014, 1, 1));
assert_eq!(from_ymd(2014, 1, 1) + Duration::seconds(86399),     from_ymd(2014, 1, 1));
assert_eq!(from_ymd(2014, 1, 1) + Duration::seconds(-86399),    from_ymd(2014, 1, 1));
assert_eq!(from_ymd(2014, 1, 1) + Duration::days(1),            from_ymd(2014, 1, 2));
assert_eq!(from_ymd(2014, 1, 1) + Duration::days(-1),           from_ymd(2013, 12, 31));
assert_eq!(from_ymd(2014, 1, 1) + Duration::days(364),          from_ymd(2014, 12, 31));
assert_eq!(from_ymd(2014, 1, 1) + Duration::days(365*4 + 1),    from_ymd(2018, 1, 1));
assert_eq!(from_ymd(2014, 1, 1) + Duration::days(365*400 + 97), from_ymd(2414, 1, 1));
§

type Output = NaiveDate

The resulting type after applying the + operator.
source§

fn add(self, rhs: Duration) -> NaiveDate

Performs the + operation. Read more
source§

impl Add<Duration> for NaiveDateTime

An addition of Duration to NaiveDateTime yields another NaiveDateTime.

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 on underflow or overflow. Use NaiveDateTime::checked_add_signed to detect that.

Example

use chrono::{Duration, NaiveDate};

let from_ymd = |y, m, d| NaiveDate::from_ymd_opt(y, m, d).unwrap();

let d = from_ymd(2016, 7, 8);
let hms = |h, m, s| d.and_hms_opt(h, m, s).unwrap();
assert_eq!(hms(3, 5, 7) + Duration::zero(),             hms(3, 5, 7));
assert_eq!(hms(3, 5, 7) + Duration::seconds(1),         hms(3, 5, 8));
assert_eq!(hms(3, 5, 7) + Duration::seconds(-1),        hms(3, 5, 6));
assert_eq!(hms(3, 5, 7) + Duration::seconds(3600 + 60), hms(4, 6, 7));
assert_eq!(hms(3, 5, 7) + Duration::seconds(86_400),
           from_ymd(2016, 7, 9).and_hms_opt(3, 5, 7).unwrap());
assert_eq!(hms(3, 5, 7) + Duration::days(365),
           from_ymd(2017, 7, 8).and_hms_opt(3, 5, 7).unwrap());

let hmsm = |h, m, s, milli| d.and_hms_milli_opt(h, m, s, milli).unwrap();
assert_eq!(hmsm(3, 5, 7, 980) + Duration::milliseconds(450), hmsm(3, 5, 8, 430));

Leap seconds are handled, but the addition assumes that it is the only leap second happened.

let leap = hmsm(3, 5, 59, 1_300);
assert_eq!(leap + Duration::zero(),             hmsm(3, 5, 59, 1_300));
assert_eq!(leap + Duration::milliseconds(-500), hmsm(3, 5, 59, 800));
assert_eq!(leap + Duration::milliseconds(500),  hmsm(3, 5, 59, 1_800));
assert_eq!(leap + Duration::milliseconds(800),  hmsm(3, 6, 0, 100));
assert_eq!(leap + Duration::seconds(10),        hmsm(3, 6, 9, 300));
assert_eq!(leap + Duration::seconds(-10),       hmsm(3, 5, 50, 300));
assert_eq!(leap + Duration::days(1),
           from_ymd(2016, 7, 9).and_hms_milli_opt(3, 5, 59, 300).unwrap());
§

type Output = NaiveDateTime

The resulting type after applying the + operator.
source§

fn add(self, rhs: Duration) -> NaiveDateTime

Performs the + operation. Read more
source§

impl Add<Duration> for NaiveTime

An addition of Duration to NaiveTime wraps around and never overflows or underflows. In particular the addition ignores integral number of days.

As a part of Chrono’s leap second handling, the addition assumes that there is no leap second ever, except when the NaiveTime itself represents a leap second in which case the assumption becomes that there is exactly a single leap second ever.

Example

use chrono::{Duration, NaiveTime};

let from_hmsm = |h, m, s, milli| { NaiveTime::from_hms_milli_opt(h, m, s, milli).unwrap() };

assert_eq!(from_hmsm(3, 5, 7, 0) + Duration::zero(),                  from_hmsm(3, 5, 7, 0));
assert_eq!(from_hmsm(3, 5, 7, 0) + Duration::seconds(1),              from_hmsm(3, 5, 8, 0));
assert_eq!(from_hmsm(3, 5, 7, 0) + Duration::seconds(-1),             from_hmsm(3, 5, 6, 0));
assert_eq!(from_hmsm(3, 5, 7, 0) + Duration::seconds(60 + 4),         from_hmsm(3, 6, 11, 0));
assert_eq!(from_hmsm(3, 5, 7, 0) + Duration::seconds(7*60*60 - 6*60), from_hmsm(9, 59, 7, 0));
assert_eq!(from_hmsm(3, 5, 7, 0) + Duration::milliseconds(80),        from_hmsm(3, 5, 7, 80));
assert_eq!(from_hmsm(3, 5, 7, 950) + Duration::milliseconds(280),     from_hmsm(3, 5, 8, 230));
assert_eq!(from_hmsm(3, 5, 7, 950) + Duration::milliseconds(-980),    from_hmsm(3, 5, 6, 970));

The addition wraps around.

assert_eq!(from_hmsm(3, 5, 7, 0) + Duration::seconds(22*60*60), from_hmsm(1, 5, 7, 0));
assert_eq!(from_hmsm(3, 5, 7, 0) + Duration::seconds(-8*60*60), from_hmsm(19, 5, 7, 0));
assert_eq!(from_hmsm(3, 5, 7, 0) + Duration::days(800),         from_hmsm(3, 5, 7, 0));

Leap seconds are handled, but the addition assumes that it is the only leap second happened.

let leap = from_hmsm(3, 5, 59, 1_300);
assert_eq!(leap + Duration::zero(),             from_hmsm(3, 5, 59, 1_300));
assert_eq!(leap + Duration::milliseconds(-500), from_hmsm(3, 5, 59, 800));
assert_eq!(leap + Duration::milliseconds(500),  from_hmsm(3, 5, 59, 1_800));
assert_eq!(leap + Duration::milliseconds(800),  from_hmsm(3, 6, 0, 100));
assert_eq!(leap + Duration::seconds(10),        from_hmsm(3, 6, 9, 300));
assert_eq!(leap + Duration::seconds(-10),       from_hmsm(3, 5, 50, 300));
assert_eq!(leap + Duration::days(1),            from_hmsm(3, 5, 59, 300));
§

type Output = NaiveTime

The resulting type after applying the + operator.
source§

fn add(self, rhs: Duration) -> NaiveTime

Performs the + operation. Read more
source§

impl<Tz> AddAssign<Duration> for Date<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 AddAssign<Duration> for NaiveDate

source§

fn add_assign(&mut self, rhs: Duration)

Performs the += operation. Read more
source§

impl AddAssign<Duration> for NaiveDateTime

source§

fn add_assign(&mut self, rhs: Duration)

Performs the += operation. Read more
source§

impl AddAssign<Duration> for NaiveTime

source§

fn add_assign(&mut self, rhs: Duration)

Performs the += operation. Read more
source§

impl Clone for Duration

source§

fn clone(&self) -> Duration

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 Debug for Duration

source§

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

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

impl<'de, FORMAT> DeserializeAs<'de, Duration> for DurationMicroSeconds<FORMAT, Flexible>where FORMAT: Format,

Available on crate feature chrono_0_4 only.
source§

fn deserialize_as<D>(deserializer: D) -> Result<Duration, D::Error>where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.
source§

impl<'de> DeserializeAs<'de, Duration> for DurationMicroSeconds<String, Strict>

Available on crate feature chrono_0_4 only.
source§

fn deserialize_as<D>(deserializer: D) -> Result<Duration, D::Error>where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.
source§

impl<'de> DeserializeAs<'de, Duration> for DurationMicroSeconds<f64, Strict>

Available on crate feature chrono_0_4 only.
source§

fn deserialize_as<D>(deserializer: D) -> Result<Duration, D::Error>where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.
source§

impl<'de> DeserializeAs<'de, Duration> for DurationMicroSeconds<i64, Strict>

Available on crate feature chrono_0_4 only.
source§

fn deserialize_as<D>(deserializer: D) -> Result<Duration, D::Error>where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.
source§

impl<'de, FORMAT> DeserializeAs<'de, Duration> for DurationMicroSecondsWithFrac<FORMAT, Flexible>where FORMAT: Format,

Available on crate feature chrono_0_4 only.
source§

fn deserialize_as<D>(deserializer: D) -> Result<Duration, D::Error>where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.
source§

impl<'de> DeserializeAs<'de, Duration> for DurationMicroSecondsWithFrac<String, Strict>

Available on crate feature chrono_0_4 only.
source§

fn deserialize_as<D>(deserializer: D) -> Result<Duration, D::Error>where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.
source§

impl<'de> DeserializeAs<'de, Duration> for DurationMicroSecondsWithFrac<f64, Strict>

Available on crate feature chrono_0_4 only.
source§

fn deserialize_as<D>(deserializer: D) -> Result<Duration, D::Error>where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.
source§

impl<'de, FORMAT> DeserializeAs<'de, Duration> for DurationMilliSeconds<FORMAT, Flexible>where FORMAT: Format,

Available on crate feature chrono_0_4 only.
source§

fn deserialize_as<D>(deserializer: D) -> Result<Duration, D::Error>where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.
source§

impl<'de> DeserializeAs<'de, Duration> for DurationMilliSeconds<String, Strict>

Available on crate feature chrono_0_4 only.
source§

fn deserialize_as<D>(deserializer: D) -> Result<Duration, D::Error>where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.
source§

impl<'de> DeserializeAs<'de, Duration> for DurationMilliSeconds<f64, Strict>

Available on crate feature chrono_0_4 only.
source§

fn deserialize_as<D>(deserializer: D) -> Result<Duration, D::Error>where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.
source§

impl<'de> DeserializeAs<'de, Duration> for DurationMilliSeconds<i64, Strict>

Available on crate feature chrono_0_4 only.
source§

fn deserialize_as<D>(deserializer: D) -> Result<Duration, D::Error>where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.
source§

impl<'de, FORMAT> DeserializeAs<'de, Duration> for DurationMilliSecondsWithFrac<FORMAT, Flexible>where FORMAT: Format,

Available on crate feature chrono_0_4 only.
source§

fn deserialize_as<D>(deserializer: D) -> Result<Duration, D::Error>where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.
source§

impl<'de> DeserializeAs<'de, Duration> for DurationMilliSecondsWithFrac<String, Strict>

Available on crate feature chrono_0_4 only.
source§

fn deserialize_as<D>(deserializer: D) -> Result<Duration, D::Error>where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.
source§

impl<'de> DeserializeAs<'de, Duration> for DurationMilliSecondsWithFrac<f64, Strict>

Available on crate feature chrono_0_4 only.
source§

fn deserialize_as<D>(deserializer: D) -> Result<Duration, D::Error>where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.
source§

impl<'de, FORMAT> DeserializeAs<'de, Duration> for DurationNanoSeconds<FORMAT, Flexible>where FORMAT: Format,

Available on crate feature chrono_0_4 only.
source§

fn deserialize_as<D>(deserializer: D) -> Result<Duration, D::Error>where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.
source§

impl<'de> DeserializeAs<'de, Duration> for DurationNanoSeconds<String, Strict>

Available on crate feature chrono_0_4 only.
source§

fn deserialize_as<D>(deserializer: D) -> Result<Duration, D::Error>where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.
source§

impl<'de> DeserializeAs<'de, Duration> for DurationNanoSeconds<f64, Strict>

Available on crate feature chrono_0_4 only.
source§

fn deserialize_as<D>(deserializer: D) -> Result<Duration, D::Error>where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.
source§

impl<'de> DeserializeAs<'de, Duration> for DurationNanoSeconds<i64, Strict>

Available on crate feature chrono_0_4 only.
source§

fn deserialize_as<D>(deserializer: D) -> Result<Duration, D::Error>where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.
source§

impl<'de, FORMAT> DeserializeAs<'de, Duration> for DurationNanoSecondsWithFrac<FORMAT, Flexible>where FORMAT: Format,

Available on crate feature chrono_0_4 only.
source§

fn deserialize_as<D>(deserializer: D) -> Result<Duration, D::Error>where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.
source§

impl<'de> DeserializeAs<'de, Duration> for DurationNanoSecondsWithFrac<String, Strict>

Available on crate feature chrono_0_4 only.
source§

fn deserialize_as<D>(deserializer: D) -> Result<Duration, D::Error>where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.
source§

impl<'de> DeserializeAs<'de, Duration> for DurationNanoSecondsWithFrac<f64, Strict>

Available on crate feature chrono_0_4 only.
source§

fn deserialize_as<D>(deserializer: D) -> Result<Duration, D::Error>where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.
source§

impl<'de, FORMAT> DeserializeAs<'de, Duration> for DurationSeconds<FORMAT, Flexible>where FORMAT: Format,

Available on crate feature chrono_0_4 only.
source§

fn deserialize_as<D>(deserializer: D) -> Result<Duration, D::Error>where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.
source§

impl<'de> DeserializeAs<'de, Duration> for DurationSeconds<String, Strict>

Available on crate feature chrono_0_4 only.
source§

fn deserialize_as<D>(deserializer: D) -> Result<Duration, D::Error>where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.
source§

impl<'de> DeserializeAs<'de, Duration> for DurationSeconds<f64, Strict>

Available on crate feature chrono_0_4 only.
source§

fn deserialize_as<D>(deserializer: D) -> Result<Duration, D::Error>where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.
source§

impl<'de> DeserializeAs<'de, Duration> for DurationSeconds<i64, Strict>

Available on crate feature chrono_0_4 only.
source§

fn deserialize_as<D>(deserializer: D) -> Result<Duration, D::Error>where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.
source§

impl<'de, FORMAT> DeserializeAs<'de, Duration> for DurationSecondsWithFrac<FORMAT, Flexible>where FORMAT: Format,

Available on crate feature chrono_0_4 only.
source§

fn deserialize_as<D>(deserializer: D) -> Result<Duration, D::Error>where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.
source§

impl<'de> DeserializeAs<'de, Duration> for DurationSecondsWithFrac<String, Strict>

Available on crate feature chrono_0_4 only.
source§

fn deserialize_as<D>(deserializer: D) -> Result<Duration, D::Error>where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.
source§

impl<'de> DeserializeAs<'de, Duration> for DurationSecondsWithFrac<f64, Strict>

Available on crate feature chrono_0_4 only.
source§

fn deserialize_as<D>(deserializer: D) -> Result<Duration, D::Error>where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.
source§

impl Display for Duration

source§

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

Format a duration using the ISO 8601 format

source§

impl Div<i32> for Duration

§

type Output = Duration

The resulting type after applying the / operator.
source§

fn div(self, rhs: i32) -> Duration

Performs the / operation. Read more
source§

impl Hash for Duration

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 Mul<i32> for Duration

§

type Output = Duration

The resulting type after applying the * operator.
source§

fn mul(self, rhs: i32) -> Duration

Performs the * operation. Read more
source§

impl Neg for Duration

§

type Output = Duration

The resulting type after applying the - operator.
source§

fn neg(self) -> Duration

Performs the unary - operation. Read more
source§

impl Ord for Duration

source§

fn cmp(&self, other: &Duration) -> 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<Self>,

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

impl PartialEq<Duration> for Duration

source§

fn eq(&self, other: &Duration) -> 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 PartialOrd<Duration> for Duration

source§

fn partial_cmp(&self, other: &Duration) -> Option<Ordering>

This method returns an ordering between self and other values if one exists. Read more
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<STRICTNESS> SerializeAs<Duration> for DurationMicroSeconds<String, STRICTNESS>where STRICTNESS: Strictness,

Available on crate feature chrono_0_4 only.
source§

fn serialize_as<S>(source: &Duration, serializer: S) -> Result<S::Ok, S::Error>where S: Serializer,

Serialize this value into the given Serde serializer.
source§

impl<STRICTNESS> SerializeAs<Duration> for DurationMicroSeconds<f64, STRICTNESS>where STRICTNESS: Strictness,

Available on crate feature chrono_0_4 only.
source§

fn serialize_as<S>(source: &Duration, serializer: S) -> Result<S::Ok, S::Error>where S: Serializer,

Serialize this value into the given Serde serializer.
source§

impl<STRICTNESS> SerializeAs<Duration> for DurationMicroSeconds<i64, STRICTNESS>where STRICTNESS: Strictness,

Available on crate feature chrono_0_4 only.
source§

fn serialize_as<S>(source: &Duration, serializer: S) -> Result<S::Ok, S::Error>where S: Serializer,

Serialize this value into the given Serde serializer.
source§

impl<STRICTNESS> SerializeAs<Duration> for DurationMicroSecondsWithFrac<String, STRICTNESS>where STRICTNESS: Strictness,

Available on crate feature chrono_0_4 only.
source§

fn serialize_as<S>(source: &Duration, serializer: S) -> Result<S::Ok, S::Error>where S: Serializer,

Serialize this value into the given Serde serializer.
source§

impl<STRICTNESS> SerializeAs<Duration> for DurationMicroSecondsWithFrac<f64, STRICTNESS>where STRICTNESS: Strictness,

Available on crate feature chrono_0_4 only.
source§

fn serialize_as<S>(source: &Duration, serializer: S) -> Result<S::Ok, S::Error>where S: Serializer,

Serialize this value into the given Serde serializer.
source§

impl<STRICTNESS> SerializeAs<Duration> for DurationMilliSeconds<String, STRICTNESS>where STRICTNESS: Strictness,

Available on crate feature chrono_0_4 only.
source§

fn serialize_as<S>(source: &Duration, serializer: S) -> Result<S::Ok, S::Error>where S: Serializer,

Serialize this value into the given Serde serializer.
source§

impl<STRICTNESS> SerializeAs<Duration> for DurationMilliSeconds<f64, STRICTNESS>where STRICTNESS: Strictness,

Available on crate feature chrono_0_4 only.
source§

fn serialize_as<S>(source: &Duration, serializer: S) -> Result<S::Ok, S::Error>where S: Serializer,

Serialize this value into the given Serde serializer.
source§

impl<STRICTNESS> SerializeAs<Duration> for DurationMilliSeconds<i64, STRICTNESS>where STRICTNESS: Strictness,

Available on crate feature chrono_0_4 only.
source§

fn serialize_as<S>(source: &Duration, serializer: S) -> Result<S::Ok, S::Error>where S: Serializer,

Serialize this value into the given Serde serializer.
source§

impl<STRICTNESS> SerializeAs<Duration> for DurationMilliSecondsWithFrac<String, STRICTNESS>where STRICTNESS: Strictness,

Available on crate feature chrono_0_4 only.
source§

fn serialize_as<S>(source: &Duration, serializer: S) -> Result<S::Ok, S::Error>where S: Serializer,

Serialize this value into the given Serde serializer.
source§

impl<STRICTNESS> SerializeAs<Duration> for DurationMilliSecondsWithFrac<f64, STRICTNESS>where STRICTNESS: Strictness,

Available on crate feature chrono_0_4 only.
source§

fn serialize_as<S>(source: &Duration, serializer: S) -> Result<S::Ok, S::Error>where S: Serializer,

Serialize this value into the given Serde serializer.
source§

impl<STRICTNESS> SerializeAs<Duration> for DurationNanoSeconds<String, STRICTNESS>where STRICTNESS: Strictness,

Available on crate feature chrono_0_4 only.
source§

fn serialize_as<S>(source: &Duration, serializer: S) -> Result<S::Ok, S::Error>where S: Serializer,

Serialize this value into the given Serde serializer.
source§

impl<STRICTNESS> SerializeAs<Duration> for DurationNanoSeconds<f64, STRICTNESS>where STRICTNESS: Strictness,

Available on crate feature chrono_0_4 only.
source§

fn serialize_as<S>(source: &Duration, serializer: S) -> Result<S::Ok, S::Error>where S: Serializer,

Serialize this value into the given Serde serializer.
source§

impl<STRICTNESS> SerializeAs<Duration> for DurationNanoSeconds<i64, STRICTNESS>where STRICTNESS: Strictness,

Available on crate feature chrono_0_4 only.
source§

fn serialize_as<S>(source: &Duration, serializer: S) -> Result<S::Ok, S::Error>where S: Serializer,

Serialize this value into the given Serde serializer.
source§

impl<STRICTNESS> SerializeAs<Duration> for DurationNanoSecondsWithFrac<String, STRICTNESS>where STRICTNESS: Strictness,

Available on crate feature chrono_0_4 only.
source§

fn serialize_as<S>(source: &Duration, serializer: S) -> Result<S::Ok, S::Error>where S: Serializer,

Serialize this value into the given Serde serializer.
source§

impl<STRICTNESS> SerializeAs<Duration> for DurationNanoSecondsWithFrac<f64, STRICTNESS>where STRICTNESS: Strictness,

Available on crate feature chrono_0_4 only.
source§

fn serialize_as<S>(source: &Duration, serializer: S) -> Result<S::Ok, S::Error>where S: Serializer,

Serialize this value into the given Serde serializer.
source§

impl<STRICTNESS> SerializeAs<Duration> for DurationSeconds<String, STRICTNESS>where STRICTNESS: Strictness,

Available on crate feature chrono_0_4 only.
source§

fn serialize_as<S>(source: &Duration, serializer: S) -> Result<S::Ok, S::Error>where S: Serializer,

Serialize this value into the given Serde serializer.
source§

impl<STRICTNESS> SerializeAs<Duration> for DurationSeconds<f64, STRICTNESS>where STRICTNESS: Strictness,

Available on crate feature chrono_0_4 only.
source§

fn serialize_as<S>(source: &Duration, serializer: S) -> Result<S::Ok, S::Error>where S: Serializer,

Serialize this value into the given Serde serializer.
source§

impl<STRICTNESS> SerializeAs<Duration> for DurationSeconds<i64, STRICTNESS>where STRICTNESS: Strictness,

Available on crate feature chrono_0_4 only.
source§

fn serialize_as<S>(source: &Duration, serializer: S) -> Result<S::Ok, S::Error>where S: Serializer,

Serialize this value into the given Serde serializer.
source§

impl<STRICTNESS> SerializeAs<Duration> for DurationSecondsWithFrac<String, STRICTNESS>where STRICTNESS: Strictness,

Available on crate feature chrono_0_4 only.
source§

fn serialize_as<S>(source: &Duration, serializer: S) -> Result<S::Ok, S::Error>where S: Serializer,

Serialize this value into the given Serde serializer.
source§

impl<STRICTNESS> SerializeAs<Duration> for DurationSecondsWithFrac<f64, STRICTNESS>where STRICTNESS: Strictness,

Available on crate feature chrono_0_4 only.
source§

fn serialize_as<S>(source: &Duration, serializer: S) -> Result<S::Ok, S::Error>where S: Serializer,

Serialize this value into the given Serde serializer.
source§

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

§

type Output = Date<Tz>

The resulting type after applying the - operator.
source§

fn sub(self, rhs: Duration) -> Date<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 Sub<Duration> for Duration

§

type Output = Duration

The resulting type after applying the - operator.
source§

fn sub(self, rhs: Duration) -> Duration

Performs the - operation. Read more
source§

impl Sub<Duration> for NaiveDate

A subtraction of Duration from NaiveDate discards the fractional days, rounding to the closest integral number of days towards Duration::zero(). It is the same as the addition with a negated Duration.

Panics on underflow or overflow. Use NaiveDate::checked_sub_signed to detect that.

Example

use chrono::{Duration, NaiveDate};

let from_ymd = |y, m, d| NaiveDate::from_ymd_opt(y, m, d).unwrap();

assert_eq!(from_ymd(2014, 1, 1) - Duration::zero(),             from_ymd(2014, 1, 1));
assert_eq!(from_ymd(2014, 1, 1) - Duration::seconds(86399),     from_ymd(2014, 1, 1));
assert_eq!(from_ymd(2014, 1, 1) - Duration::seconds(-86399),    from_ymd(2014, 1, 1));
assert_eq!(from_ymd(2014, 1, 1) - Duration::days(1),            from_ymd(2013, 12, 31));
assert_eq!(from_ymd(2014, 1, 1) - Duration::days(-1),           from_ymd(2014, 1, 2));
assert_eq!(from_ymd(2014, 1, 1) - Duration::days(364),          from_ymd(2013, 1, 2));
assert_eq!(from_ymd(2014, 1, 1) - Duration::days(365*4 + 1),    from_ymd(2010, 1, 1));
assert_eq!(from_ymd(2014, 1, 1) - Duration::days(365*400 + 97), from_ymd(1614, 1, 1));
§

type Output = NaiveDate

The resulting type after applying the - operator.
source§

fn sub(self, rhs: Duration) -> NaiveDate

Performs the - operation. Read more
source§

impl Sub<Duration> for NaiveDateTime

A subtraction of Duration from NaiveDateTime yields another NaiveDateTime. It is the same as the addition with a negated Duration.

As a part of Chrono’s leap second handling the subtraction 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 on underflow or overflow. Use NaiveDateTime::checked_sub_signed to detect that.

Example

use chrono::{Duration, NaiveDate};

let from_ymd = |y, m, d| NaiveDate::from_ymd_opt(y, m, d).unwrap();

let d = from_ymd(2016, 7, 8);
let hms = |h, m, s| d.and_hms_opt(h, m, s).unwrap();
assert_eq!(hms(3, 5, 7) - Duration::zero(),             hms(3, 5, 7));
assert_eq!(hms(3, 5, 7) - Duration::seconds(1),         hms(3, 5, 6));
assert_eq!(hms(3, 5, 7) - Duration::seconds(-1),        hms(3, 5, 8));
assert_eq!(hms(3, 5, 7) - Duration::seconds(3600 + 60), hms(2, 4, 7));
assert_eq!(hms(3, 5, 7) - Duration::seconds(86_400),
           from_ymd(2016, 7, 7).and_hms_opt(3, 5, 7).unwrap());
assert_eq!(hms(3, 5, 7) - Duration::days(365),
           from_ymd(2015, 7, 9).and_hms_opt(3, 5, 7).unwrap());

let hmsm = |h, m, s, milli| d.and_hms_milli_opt(h, m, s, milli).unwrap();
assert_eq!(hmsm(3, 5, 7, 450) - Duration::milliseconds(670), hmsm(3, 5, 6, 780));

Leap seconds are handled, but the subtraction assumes that it is the only leap second happened.

let leap = hmsm(3, 5, 59, 1_300);
assert_eq!(leap - Duration::zero(),            hmsm(3, 5, 59, 1_300));
assert_eq!(leap - Duration::milliseconds(200), hmsm(3, 5, 59, 1_100));
assert_eq!(leap - Duration::milliseconds(500), hmsm(3, 5, 59, 800));
assert_eq!(leap - Duration::seconds(60),       hmsm(3, 5, 0, 300));
assert_eq!(leap - Duration::days(1),
           from_ymd(2016, 7, 7).and_hms_milli_opt(3, 6, 0, 300).unwrap());
§

type Output = NaiveDateTime

The resulting type after applying the - operator.
source§

fn sub(self, rhs: Duration) -> NaiveDateTime

Performs the - operation. Read more
source§

impl Sub<Duration> for NaiveTime

A subtraction of Duration from NaiveTime wraps around and never overflows or underflows. In particular the addition ignores integral number of days. It is the same as the addition with a negated Duration.

As a part of Chrono’s leap second handling, the subtraction assumes that there is no leap second ever, except when the NaiveTime itself represents a leap second in which case the assumption becomes that there is exactly a single leap second ever.

Example

use chrono::{Duration, NaiveTime};

let from_hmsm = |h, m, s, milli| { NaiveTime::from_hms_milli_opt(h, m, s, milli).unwrap() };

assert_eq!(from_hmsm(3, 5, 7, 0) - Duration::zero(),                  from_hmsm(3, 5, 7, 0));
assert_eq!(from_hmsm(3, 5, 7, 0) - Duration::seconds(1),              from_hmsm(3, 5, 6, 0));
assert_eq!(from_hmsm(3, 5, 7, 0) - Duration::seconds(60 + 5),         from_hmsm(3, 4, 2, 0));
assert_eq!(from_hmsm(3, 5, 7, 0) - Duration::seconds(2*60*60 + 6*60), from_hmsm(0, 59, 7, 0));
assert_eq!(from_hmsm(3, 5, 7, 0) - Duration::milliseconds(80),        from_hmsm(3, 5, 6, 920));
assert_eq!(from_hmsm(3, 5, 7, 950) - Duration::milliseconds(280),     from_hmsm(3, 5, 7, 670));

The subtraction wraps around.

assert_eq!(from_hmsm(3, 5, 7, 0) - Duration::seconds(8*60*60), from_hmsm(19, 5, 7, 0));
assert_eq!(from_hmsm(3, 5, 7, 0) - Duration::days(800),        from_hmsm(3, 5, 7, 0));

Leap seconds are handled, but the subtraction assumes that it is the only leap second happened.

let leap = from_hmsm(3, 5, 59, 1_300);
assert_eq!(leap - Duration::zero(),            from_hmsm(3, 5, 59, 1_300));
assert_eq!(leap - Duration::milliseconds(200), from_hmsm(3, 5, 59, 1_100));
assert_eq!(leap - Duration::milliseconds(500), from_hmsm(3, 5, 59, 800));
assert_eq!(leap - Duration::seconds(60),       from_hmsm(3, 5, 0, 300));
assert_eq!(leap - Duration::days(1),           from_hmsm(3, 6, 0, 300));
§

type Output = NaiveTime

The resulting type after applying the - operator.
source§

fn sub(self, rhs: Duration) -> NaiveTime

Performs the - operation. Read more
source§

impl<Tz> SubAssign<Duration> for Date<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 SubAssign<Duration> for NaiveDate

source§

fn sub_assign(&mut self, rhs: Duration)

Performs the -= operation. Read more
source§

impl SubAssign<Duration> for NaiveDateTime

source§

fn sub_assign(&mut self, rhs: Duration)

Performs the -= operation. Read more
source§

impl SubAssign<Duration> for NaiveTime

source§

fn sub_assign(&mut self, rhs: Duration)

Performs the -= operation. Read more
source§

impl<'a> Sum<&'a Duration> for Duration

source§

fn sum<I>(iter: I) -> Durationwhere I: Iterator<Item = &'a Duration>,

Method which takes an iterator and generates Self from the elements by “summing up” the items.
source§

impl Sum<Duration> for Duration

source§

fn sum<I>(iter: I) -> Durationwhere I: Iterator<Item = Duration>,

Method which takes an iterator and generates Self from the elements by “summing up” the items.
source§

impl Copy for Duration

source§

impl Eq for Duration

source§

impl StructuralEq for Duration

source§

impl StructuralPartialEq for Duration

Auto Trait Implementations§

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.

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.

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.