Struct chrono::Duration [−][src]
pub struct Duration { /* fields omitted */ }
ISO 8601 time duration with nanosecond precision. This also allows for the negative duration; see individual methods for details.
Implementations
impl Duration
[src]
impl Duration
[src]pub fn weeks(weeks: i64) -> Duration
[src]
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.
pub fn days(days: i64) -> Duration
[src]
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.
pub fn hours(hours: i64) -> Duration
[src]
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.
pub fn minutes(minutes: i64) -> Duration
[src]
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.
pub fn seconds(seconds: i64) -> Duration
[src]
Makes a new Duration
with given number of seconds.
Panics when the duration is more than i64::MAX
milliseconds
or less than i64::MIN
milliseconds.
pub fn milliseconds(milliseconds: i64) -> Duration
[src]
Makes a new Duration
with given number of milliseconds.
pub fn microseconds(microseconds: i64) -> Duration
[src]
Makes a new Duration
with given number of microseconds.
pub fn nanoseconds(nanos: i64) -> Duration
[src]
Makes a new Duration
with given number of nanoseconds.
pub fn span<F>(f: F) -> Duration where
F: FnOnce(),
[src]
F: FnOnce(),
Runs a closure, returning the duration of time it took to run the closure.
pub fn num_weeks(&self) -> i64
[src]
Returns the total number of whole weeks in the duration.
pub fn num_days(&self) -> i64
[src]
Returns the total number of whole days in the duration.
pub fn num_hours(&self) -> i64
[src]
Returns the total number of whole hours in the duration.
pub fn num_minutes(&self) -> i64
[src]
Returns the total number of whole minutes in the duration.
pub fn num_seconds(&self) -> i64
[src]
Returns the total number of whole seconds in the duration.
pub fn num_milliseconds(&self) -> i64
[src]
Returns the total number of whole milliseconds in the duration,
pub fn num_microseconds(&self) -> Option<i64>
[src]
Returns the total number of whole microseconds in the duration,
or None
on overflow (exceeding 263 microseconds in either direction).
pub fn num_nanoseconds(&self) -> Option<i64>
[src]
Returns the total number of whole nanoseconds in the duration,
or None
on overflow (exceeding 263 nanoseconds in either direction).
pub fn checked_add(&self, rhs: &Duration) -> Option<Duration>
[src]
Add two durations, returning None
if overflow occurred.
pub fn checked_sub(&self, rhs: &Duration) -> Option<Duration>
[src]
Subtract two durations, returning None
if overflow occurred.
pub fn min_value() -> Duration
[src]
The minimum possible Duration
: i64::MIN
milliseconds.
pub fn max_value() -> Duration
[src]
The maximum possible Duration
: i64::MAX
milliseconds.
pub fn zero() -> Duration
[src]
A duration where the stored seconds and nanoseconds are equal to zero.
pub fn is_zero(&self) -> bool
[src]
Returns true
if the duration equals Duration::zero()
.
pub fn from_std(duration: Duration) -> Result<Duration, OutOfRangeError>
[src]
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.
pub fn to_std(&self) -> Result<Duration, OutOfRangeError>
[src]
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
impl Add<Duration> for NaiveDate
[src]
impl Add<Duration> for NaiveDate
[src]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 = NaiveDate::from_ymd; 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));
impl Add<Duration> for NaiveDateTime
[src]
impl Add<Duration> for NaiveDateTime
[src]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 = NaiveDate::from_ymd; let d = from_ymd(2016, 7, 8); let hms = |h, m, s| d.and_hms(h, m, s); 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(3, 5, 7)); assert_eq!(hms(3, 5, 7) + Duration::days(365), from_ymd(2017, 7, 8).and_hms(3, 5, 7)); let hmsm = |h, m, s, milli| d.and_hms_milli(h, m, s, milli); 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(3, 5, 59, 300));
type Output = NaiveDateTime
The resulting type after applying the +
operator.
fn add(self, rhs: OldDuration) -> NaiveDateTime
[src]
impl Add<Duration> for NaiveTime
[src]
impl Add<Duration> for NaiveTime
[src]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 = NaiveTime::from_hms_milli; 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));
impl AddAssign<Duration> for NaiveDate
[src]
impl AddAssign<Duration> for NaiveDate
[src]fn add_assign(&mut self, rhs: OldDuration)
[src]
impl AddAssign<Duration> for NaiveDateTime
[src]
impl AddAssign<Duration> for NaiveDateTime
[src]fn add_assign(&mut self, rhs: OldDuration)
[src]
impl AddAssign<Duration> for NaiveTime
[src]
impl AddAssign<Duration> for NaiveTime
[src]fn add_assign(&mut self, rhs: OldDuration)
[src]
impl PartialOrd<Duration> for Duration
[src]
impl PartialOrd<Duration> for Duration
[src]pub fn partial_cmp(&self, other: &Duration) -> Option<Ordering>
[src]
#[must_use]pub fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]pub fn le(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]pub fn gt(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]pub fn ge(&self, other: &Rhs) -> bool
1.0.0[src]
impl Sub<Duration> for NaiveDate
[src]
impl Sub<Duration> for NaiveDate
[src]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 = NaiveDate::from_ymd; 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));
impl Sub<Duration> for NaiveDateTime
[src]
impl Sub<Duration> for NaiveDateTime
[src]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 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_sub_signed
to detect that.
Example
use chrono::{Duration, NaiveDate}; let from_ymd = NaiveDate::from_ymd; let d = from_ymd(2016, 7, 8); let hms = |h, m, s| d.and_hms(h, m, s); 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(3, 5, 7)); assert_eq!(hms(3, 5, 7) - Duration::days(365), from_ymd(2015, 7, 9).and_hms(3, 5, 7)); let hmsm = |h, m, s, milli| d.and_hms_milli(h, m, s, milli); 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(3, 6, 0, 300));
type Output = NaiveDateTime
The resulting type after applying the -
operator.
fn sub(self, rhs: OldDuration) -> NaiveDateTime
[src]
impl Sub<Duration> for NaiveTime
[src]
impl Sub<Duration> for NaiveTime
[src]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 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 = NaiveTime::from_hms_milli; 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));
impl SubAssign<Duration> for NaiveDate
[src]
impl SubAssign<Duration> for NaiveDate
[src]fn sub_assign(&mut self, rhs: OldDuration)
[src]
impl SubAssign<Duration> for NaiveDateTime
[src]
impl SubAssign<Duration> for NaiveDateTime
[src]fn sub_assign(&mut self, rhs: OldDuration)
[src]
impl SubAssign<Duration> for NaiveTime
[src]
impl SubAssign<Duration> for NaiveTime
[src]