pub const MAX_DATE: Date<Utc>;
The maximum possible Date.
pub const MAX_DATETIME: DateTime<Utc>;
The maximum possible DateTime<Utc>.
pub const MIN_DATE: Date<Utc>;
The minimum possible Date.
pub const MIN_DATETIME: DateTime<Utc>;
The minimum possible DateTime<Utc>.
Redirecting to ../../chrono/constant.MAX_DATE.html...
- - - \ No newline at end of file diff --git a/docs/chrono/date/constant.MIN_DATE.html b/docs/chrono/date/constant.MIN_DATE.html deleted file mode 100644 index 7be73ede..00000000 --- a/docs/chrono/date/constant.MIN_DATE.html +++ /dev/null @@ -1,10 +0,0 @@ - - - - - - -Redirecting to ../../chrono/constant.MIN_DATE.html...
- - - \ No newline at end of file diff --git a/docs/chrono/date/struct.Date.html b/docs/chrono/date/struct.Date.html deleted file mode 100644 index 1239b601..00000000 --- a/docs/chrono/date/struct.Date.html +++ /dev/null @@ -1,10 +0,0 @@ - - - - - - -Redirecting to ../../chrono/struct.Date.html...
- - - \ No newline at end of file diff --git a/docs/chrono/datetime/constant.MAX_DATETIME.html b/docs/chrono/datetime/constant.MAX_DATETIME.html deleted file mode 100644 index fc29ea84..00000000 --- a/docs/chrono/datetime/constant.MAX_DATETIME.html +++ /dev/null @@ -1,10 +0,0 @@ - - - - - - -Redirecting to ../../chrono/constant.MAX_DATETIME.html...
- - - \ No newline at end of file diff --git a/docs/chrono/datetime/constant.MIN_DATETIME.html b/docs/chrono/datetime/constant.MIN_DATETIME.html deleted file mode 100644 index e7ce3f6c..00000000 --- a/docs/chrono/datetime/constant.MIN_DATETIME.html +++ /dev/null @@ -1,10 +0,0 @@ - - - - - - -Redirecting to ../../chrono/constant.MIN_DATETIME.html...
- - - \ No newline at end of file diff --git a/docs/chrono/datetime/enum.SecondsFormat.html b/docs/chrono/datetime/enum.SecondsFormat.html deleted file mode 100644 index 26123ce9..00000000 --- a/docs/chrono/datetime/enum.SecondsFormat.html +++ /dev/null @@ -1,10 +0,0 @@ - - - - - - -Redirecting to ../../chrono/enum.SecondsFormat.html...
- - - \ No newline at end of file diff --git a/docs/chrono/datetime/struct.DateTime.html b/docs/chrono/datetime/struct.DateTime.html deleted file mode 100644 index 7af8741a..00000000 --- a/docs/chrono/datetime/struct.DateTime.html +++ /dev/null @@ -1,10 +0,0 @@ - - - - - - -Redirecting to ../../chrono/struct.DateTime.html...
- - - \ No newline at end of file diff --git a/docs/chrono/enum.Month.html b/docs/chrono/enum.Month.html deleted file mode 100644 index b839f78d..00000000 --- a/docs/chrono/enum.Month.html +++ /dev/null @@ -1,138 +0,0 @@ -The month of the year.
-This enum is just a convenience implementation. -The month in dates created by DateLike objects does not return this enum.
-It is possible to convert from a date to a month independently
- --use num_traits::FromPrimitive; -use chrono::prelude::*; -let date = Utc.ymd(2019, 10, 28).and_hms(9, 10, 11); -// `2019-10-28T09:10:11Z` -let month = Month::from_u32(date.month()); -assert_eq!(month, Some(Month::October))
Or from a Month to an integer usable by dates
- --let month = Month::January; -let dt = Utc.ymd(2019, month.number_from_month(), 28).and_hms(9, 10, 11); -assert_eq!((dt.year(), dt.month(), dt.day()), (2019, 1, 28));
Allows mapping from and to month, from 1-January to 12-December. -Can be Serialized/Deserialized with serde
-January
-February
-March
-April
-May
-June
-July
-August
-September
-October
-November
-December
-impl Month[src]pub fn succ(&self) -> Month[src]The next month.
-m: | January | February | ... | December |
|---|---|---|---|---|
m.succ(): | February | March | ... | January |
pub fn pred(&self) -> Month[src]The previous month.
-m: | January | February | ... | December |
|---|---|---|---|---|
m.succ(): | December | January | ... | November |
pub fn number_from_month(&self) -> u32[src]Returns a month-of-year number starting from January = 1.
-m: | January | February | ... | December |
|---|---|---|---|---|
m.number_from_month(): | 1 | 2 | ... | 12 |
pub fn name(&self) -> &'static str[src]Get the name of the month
- --use chrono::Month; - -assert_eq!(Month::January.name(), "January")
impl Clone for Month[src]impl Copy for Month[src]impl Debug for Month[src]impl Eq for Month[src]impl FromPrimitive for Month[src]fn from_u64(n: u64) -> Option<Month>[src]Returns an Option
Month::from_i64(n: i64): | 1 | 2 | ... | 12
----------------------------| -------------------- | --------------------- | ... | -----
-``: | Some(Month::January) | Some(Month::February) | ... | Some(Month::December)
fn from_i64(n: i64) -> Option<Month>[src]fn from_u32(n: u32) -> Option<Month>[src]pub fn from_isize(n: isize) -> Option<Self>[src]pub fn from_i8(n: i8) -> Option<Self>[src]pub fn from_i16(n: i16) -> Option<Self>[src]pub fn from_i32(n: i32) -> Option<Self>[src]pub fn from_i128(n: i128) -> Option<Self>[src]pub fn from_usize(n: usize) -> Option<Self>[src]pub fn from_u8(n: u8) -> Option<Self>[src]pub fn from_u16(n: u16) -> Option<Self>[src]pub fn from_u128(n: u128) -> Option<Self>[src]pub fn from_f32(n: f32) -> Option<Self>[src]pub fn from_f64(n: f64) -> Option<Self>[src]impl FromStr for Month[src]Parsing a str into a Month uses the format %W.
-use chrono::Month; - -assert_eq!("January".parse::<Month>(), Ok(Month::January)); -assert!("any day".parse::<Month>().is_err());
The parsing is case-insensitive.
- --assert_eq!("fEbruARy".parse::<Month>(), Ok(Month::February));
Only the shortest form (e.g. jan) and the longest form (e.g. january) is accepted.
-assert!("septem".parse::<Month>().is_err()); -assert!("Augustin".parse::<Month>().is_err());
type Err = ParseMonthErrorThe associated error which can be returned from parsing.
-fn from_str(s: &str) -> Result<Self, Self::Err>[src]impl Hash for Month[src]fn hash<__H: Hasher>(&self, state: &mut __H)[src]pub fn hash_slice<H>(data: &[Self], state: &mut H) where
H: Hasher, 1.3.0[src]impl PartialEq<Month> for Month[src]impl StructuralEq for Month[src]impl StructuralPartialEq for Month[src]impl RefUnwindSafe for Month[src]impl Send for Month[src]impl Sync for Month[src]impl Unpin for Month[src]impl UnwindSafe for Month[src]impl<T> Any for T where
T: 'static + ?Sized, [src]impl<T> Borrow<T> for T where
T: ?Sized, [src]impl<T> BorrowMut<T> for T where
T: ?Sized, [src]pub fn borrow_mut(&mut self) -> &mut T[src]impl<T> From<T> for T[src]impl<T, U> Into<U> for T where
U: From<T>, [src]impl<T> ToOwned for T where
T: Clone, [src]type Owned = TThe resulting type after obtaining ownership.
-pub fn to_owned(&self) -> T[src]pub fn clone_into(&self, target: &mut T)[src]impl<T, U> TryFrom<U> for T where
U: Into<T>, [src]type Error = InfallibleThe type returned in the event of a conversion error.
-pub fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]impl<T, U> TryInto<U> for T where
U: TryFrom<T>, [src]An error from rounding by Duration
See: DurationRound
Error when the Duration exceeds the Duration from or until the Unix epoch.
- --let dt = Utc.ymd(1970, 12, 12).and_hms(0, 0, 0); - -assert_eq!( - dt.duration_round(Duration::days(365)), - Err(RoundingError::DurationExceedsTimestamp), -);
Error when Duration.num_nanoseconds exceeds the limit.
-let dt = Utc.ymd(2260, 12, 31).and_hms_nano(23, 59, 59, 1_75_500_000); - -assert_eq!( - dt.duration_round(Duration::days(300 * 365)), - Err(RoundingError::DurationExceedsLimit) -);
Error when DateTime.timestamp_nanos exceeds the limit.
-let dt = Utc.ymd(2300, 12, 12).and_hms(0, 0, 0); - -assert_eq!(dt.duration_round(Duration::days(1)), Err(RoundingError::TimestampExceedsLimit),);
impl Clone for RoundingError[src]fn clone(&self) -> RoundingError[src]pub fn clone_from(&mut self, source: &Self)1.0.0[src]impl Copy for RoundingError[src]impl Debug for RoundingError[src]impl Display for RoundingError[src]impl Eq for RoundingError[src]impl Error for RoundingError[src]fn description(&self) -> &str[src]pub fn source(&self) -> Option<&(dyn Error + 'static)>1.30.0[src]pub fn backtrace(&self) -> Option<&Backtrace>[src]pub fn cause(&self) -> Option<&dyn Error>1.0.0[src]impl PartialEq<RoundingError> for RoundingError[src]fn eq(&self, other: &RoundingError) -> bool[src]#[must_use]pub fn ne(&self, other: &Rhs) -> bool1.0.0[src]impl StructuralEq for RoundingError[src]impl StructuralPartialEq for RoundingError[src]impl RefUnwindSafe for RoundingError[src]impl Send for RoundingError[src]impl Sync for RoundingError[src]impl Unpin for RoundingError[src]impl UnwindSafe for RoundingError[src]impl<T> Any for T where
T: 'static + ?Sized, [src]impl<T> Borrow<T> for T where
T: ?Sized, [src]impl<T> BorrowMut<T> for T where
T: ?Sized, [src]pub fn borrow_mut(&mut self) -> &mut T[src]impl<T> From<T> for T[src]impl<T, U> Into<U> for T where
U: From<T>, [src]impl<T> ToOwned for T where
T: Clone, [src]type Owned = TThe resulting type after obtaining ownership.
-pub fn to_owned(&self) -> T[src]pub fn clone_into(&self, target: &mut T)[src]impl<T> ToString for T where
T: Display + ?Sized, [src]impl<T, U> TryFrom<U> for T where
U: Into<T>, [src]type Error = InfallibleThe type returned in the event of a conversion error.
-pub fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]impl<T, U> TryInto<U> for T where
U: TryFrom<T>, [src]Specific formatting options for seconds. This may be extended in the -future, so exhaustive matching in external code is not recommended.
-See the TimeZone::to_rfc3339_opts function for usage.
Format whole seconds only, with no decimal point nor subseconds.
-Use fixed 3 subsecond digits. This corresponds to -Fixed::Nanosecond3.
-Use fixed 6 subsecond digits. This corresponds to -Fixed::Nanosecond6.
-Use fixed 9 subsecond digits. This corresponds to -Fixed::Nanosecond9.
-Automatically select one of Secs, Millis, Micros, or Nanos to
-display all available non-zero sub-second digits. This corresponds to
-Fixed::Nanosecond.
impl Clone for SecondsFormat[src]fn clone(&self) -> SecondsFormat[src]pub fn clone_from(&mut self, source: &Self)1.0.0[src]impl Copy for SecondsFormat[src]impl Debug for SecondsFormat[src]impl Eq for SecondsFormat[src]impl PartialEq<SecondsFormat> for SecondsFormat[src]fn eq(&self, other: &SecondsFormat) -> bool[src]#[must_use]pub fn ne(&self, other: &Rhs) -> bool1.0.0[src]impl StructuralEq for SecondsFormat[src]impl StructuralPartialEq for SecondsFormat[src]impl RefUnwindSafe for SecondsFormat[src]impl Send for SecondsFormat[src]impl Sync for SecondsFormat[src]impl Unpin for SecondsFormat[src]impl UnwindSafe for SecondsFormat[src]impl<T> Any for T where
T: 'static + ?Sized, [src]impl<T> Borrow<T> for T where
T: ?Sized, [src]impl<T> BorrowMut<T> for T where
T: ?Sized, [src]pub fn borrow_mut(&mut self) -> &mut T[src]impl<T> From<T> for T[src]impl<T, U> Into<U> for T where
U: From<T>, [src]impl<T> ToOwned for T where
T: Clone, [src]type Owned = TThe resulting type after obtaining ownership.
-pub fn to_owned(&self) -> T[src]pub fn clone_into(&self, target: &mut T)[src]impl<T, U> TryFrom<U> for T where
U: Into<T>, [src]type Error = InfallibleThe type returned in the event of a conversion error.
-pub fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]impl<T, U> TryInto<U> for T where
U: TryFrom<T>, [src]The day of week.
-The order of the days of week depends on the context.
-(This is why this type does not implement PartialOrd or Ord traits.)
-One should prefer *_from_monday or *_from_sunday methods to get the correct result.
Monday.
-Tuesday.
-Wednesday.
-Thursday.
-Friday.
-Saturday.
-Sunday.
-impl Weekday[src]pub fn succ(&self) -> Weekday[src]The next day in the week.
-w: | Mon | Tue | Wed | Thu | Fri | Sat | Sun |
|---|---|---|---|---|---|---|---|
w.succ(): | Tue | Wed | Thu | Fri | Sat | Sun | Mon |
pub fn pred(&self) -> Weekday[src]The previous day in the week.
-w: | Mon | Tue | Wed | Thu | Fri | Sat | Sun |
|---|---|---|---|---|---|---|---|
w.pred(): | Sun | Mon | Tue | Wed | Thu | Fri | Sat |
pub fn number_from_monday(&self) -> u32[src]Returns a day-of-week number starting from Monday = 1. (ISO 8601 weekday number)
-w: | Mon | Tue | Wed | Thu | Fri | Sat | Sun |
|---|---|---|---|---|---|---|---|
w.number_from_monday(): | 1 | 2 | 3 | 4 | 5 | 6 | 7 |
pub fn number_from_sunday(&self) -> u32[src]Returns a day-of-week number starting from Sunday = 1.
-w: | Mon | Tue | Wed | Thu | Fri | Sat | Sun |
|---|---|---|---|---|---|---|---|
w.number_from_sunday(): | 2 | 3 | 4 | 5 | 6 | 7 | 1 |
pub fn num_days_from_monday(&self) -> u32[src]Returns a day-of-week number starting from Monday = 0.
-w: | Mon | Tue | Wed | Thu | Fri | Sat | Sun |
|---|---|---|---|---|---|---|---|
w.num_days_from_monday(): | 0 | 1 | 2 | 3 | 4 | 5 | 6 |
pub fn num_days_from_sunday(&self) -> u32[src]Returns a day-of-week number starting from Sunday = 0.
-w: | Mon | Tue | Wed | Thu | Fri | Sat | Sun |
|---|---|---|---|---|---|---|---|
w.num_days_from_sunday(): | 1 | 2 | 3 | 4 | 5 | 6 | 0 |
impl Clone for Weekday[src]impl Copy for Weekday[src]impl Debug for Weekday[src]impl Display for Weekday[src]impl Eq for Weekday[src]impl FromPrimitive for Weekday[src]Any weekday can be represented as an integer from 0 to 6, which equals to
-Weekday::num_days_from_monday in this implementation.
-Do not heavily depend on this though; use explicit methods whenever possible.
fn from_i64(n: i64) -> Option<Weekday>[src]fn from_u64(n: u64) -> Option<Weekday>[src]pub fn from_isize(n: isize) -> Option<Self>[src]pub fn from_i8(n: i8) -> Option<Self>[src]pub fn from_i16(n: i16) -> Option<Self>[src]pub fn from_i32(n: i32) -> Option<Self>[src]pub fn from_i128(n: i128) -> Option<Self>[src]pub fn from_usize(n: usize) -> Option<Self>[src]pub fn from_u8(n: u8) -> Option<Self>[src]pub fn from_u16(n: u16) -> Option<Self>[src]pub fn from_u32(n: u32) -> Option<Self>[src]pub fn from_u128(n: u128) -> Option<Self>[src]pub fn from_f32(n: f32) -> Option<Self>[src]pub fn from_f64(n: f64) -> Option<Self>[src]impl FromStr for Weekday[src]Parsing a str into a Weekday uses the format %W.
-use chrono::Weekday; - -assert_eq!("Sunday".parse::<Weekday>(), Ok(Weekday::Sun)); -assert!("any day".parse::<Weekday>().is_err());
The parsing is case-insensitive.
- --assert_eq!("mON".parse::<Weekday>(), Ok(Weekday::Mon));
Only the shortest form (e.g. sun) and the longest form (e.g. sunday) is accepted.
-assert!("thurs".parse::<Weekday>().is_err());
type Err = ParseWeekdayErrorThe associated error which can be returned from parsing.
-fn from_str(s: &str) -> Result<Self, Self::Err>[src]impl Hash for Weekday[src]fn hash<__H: Hasher>(&self, state: &mut __H)[src]pub fn hash_slice<H>(data: &[Self], state: &mut H) where
H: Hasher, 1.3.0[src]impl PartialEq<Weekday> for Weekday[src]fn eq(&self, other: &Weekday) -> bool[src]#[must_use]pub fn ne(&self, other: &Rhs) -> bool1.0.0[src]impl StructuralEq for Weekday[src]impl StructuralPartialEq for Weekday[src]impl RefUnwindSafe for Weekday[src]impl Send for Weekday[src]impl Sync for Weekday[src]impl Unpin for Weekday[src]impl UnwindSafe for Weekday[src]impl<T> Any for T where
T: 'static + ?Sized, [src]impl<T> Borrow<T> for T where
T: ?Sized, [src]impl<T> BorrowMut<T> for T where
T: ?Sized, [src]pub fn borrow_mut(&mut self) -> &mut T[src]impl<T> From<T> for T[src]impl<T, U> Into<U> for T where
U: From<T>, [src]impl<T> ToOwned for T where
T: Clone, [src]type Owned = TThe resulting type after obtaining ownership.
-pub fn to_owned(&self) -> T[src]pub fn clone_into(&self, target: &mut T)[src]impl<T> ToString for T where
T: Display + ?Sized, [src]impl<T, U> TryFrom<U> for T where
U: Into<T>, [src]type Error = InfallibleThe type returned in the event of a conversion error.
-pub fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]impl<T, U> TryInto<U> for T where
U: TryFrom<T>, [src]Fixed-format item types.
-They have their own rules of formatting and parsing. -Otherwise noted, they print in the specified cases but parse case-insensitively.
-Abbreviated month names.
-Prints a three-letter-long name in the title case, reads the same name in any case.
-Full month names.
-Prints a full name in the title case, reads either a short or full name in any case.
-Abbreviated day of the week names.
-Prints a three-letter-long name in the title case, reads the same name in any case.
-Full day of the week names.
-Prints a full name in the title case, reads either a short or full name in any case.
-AM/PM.
-Prints in lower case, reads in any case.
-AM/PM.
-Prints in upper case, reads in any case.
-An optional dot plus one or more digits for left-aligned nanoseconds.
-May print nothing, 3, 6 or 9 digits according to the available accuracy.
-See also Numeric::Nanosecond.
Same as Nanosecond but the accuracy is fixed to 3.
Same as Nanosecond but the accuracy is fixed to 6.
Same as Nanosecond but the accuracy is fixed to 9.
Timezone name.
-It does not support parsing, its use in the parser is an immediate failure.
-Offset from the local time to UTC (+09:00 or -04:00 or +00:00).
In the parser, the colon can be omitted and/or surrounded with any amount of whitespace.
-The offset is limited from -24:00 to +24:00,
-which is the same as FixedOffset's range.
Offset from the local time to UTC (+09:00 or -04:00 or Z).
In the parser, the colon can be omitted and/or surrounded with any amount of whitespace,
-and Z can be either in upper case or in lower case.
-The offset is limited from -24:00 to +24:00,
-which is the same as FixedOffset's range.
Same as TimezoneOffsetColon but prints no colon.
-Parsing allows an optional colon.
Same as TimezoneOffsetColonZ but prints no colon.
-Parsing allows an optional colon.
RFC 2822 date and time syntax. Commonly used for email and MIME date and time.
-RFC 3339 & ISO 8601 date and time syntax.
-Internal(InternalFixed)Internal uses only.
-This item exists so that one can add additional internal-only formatting -without breaking major compatibility (as enum variants cannot be selectively private).
-impl Clone for Fixed[src]impl Debug for Fixed[src]impl Eq for Fixed[src]impl PartialEq<Fixed> for Fixed[src]impl StructuralEq for Fixed[src]impl StructuralPartialEq for Fixed[src]impl RefUnwindSafe for Fixed[src]impl Send for Fixed[src]impl Sync for Fixed[src]impl Unpin for Fixed[src]impl UnwindSafe for Fixed[src]impl<T> Any for T where
T: 'static + ?Sized, [src]impl<T> Borrow<T> for T where
T: ?Sized, [src]impl<T> BorrowMut<T> for T where
T: ?Sized, [src]pub fn borrow_mut(&mut self) -> &mut T[src]impl<T> From<T> for T[src]impl<T, U> Into<U> for T where
U: From<T>, [src]impl<T> ToOwned for T where
T: Clone, [src]type Owned = TThe resulting type after obtaining ownership.
-pub fn to_owned(&self) -> T[src]pub fn clone_into(&self, target: &mut T)[src]impl<T, U> TryFrom<U> for T where
U: Into<T>, [src]type Error = InfallibleThe type returned in the event of a conversion error.
-pub fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]impl<T, U> TryInto<U> for T where
U: TryFrom<T>, [src]A single formatting item. This is used for both formatting and parsing.
-Literal(&'a str)A literally printed and parsed text.
-Same as Literal but with the string owned by the item.
Space(&'a str)Whitespace. Prints literally but reads zero or more whitespace.
-Same as Space but with the string owned by the item.
Numeric item. Can be optionally padded to the maximal length (if any) when formatting; -the parser simply ignores any padded whitespace and zeroes.
-Fixed(Fixed)Fixed-format item.
-Issues a formatting error. Used to signal an invalid format string.
-impl<'a> Clone for Item<'a>[src]impl<'a> Debug for Item<'a>[src]impl<'a> Eq for Item<'a>[src]impl<'a> PartialEq<Item<'a>> for Item<'a>[src]impl<'a> StructuralEq for Item<'a>[src]impl<'a> StructuralPartialEq for Item<'a>[src]impl<'a> RefUnwindSafe for Item<'a>[src]impl<'a> Send for Item<'a>[src]impl<'a> Sync for Item<'a>[src]impl<'a> Unpin for Item<'a>[src]impl<'a> UnwindSafe for Item<'a>[src]impl<T> Any for T where
T: 'static + ?Sized, [src]impl<T> Borrow<T> for T where
T: ?Sized, [src]impl<T> BorrowMut<T> for T where
T: ?Sized, [src]pub fn borrow_mut(&mut self) -> &mut T[src]impl<T> From<T> for T[src]impl<T, U> Into<U> for T where
U: From<T>, [src]impl<T> ToOwned for T where
T: Clone, [src]type Owned = TThe resulting type after obtaining ownership.
-pub fn to_owned(&self) -> T[src]pub fn clone_into(&self, target: &mut T)[src]impl<T, U> TryFrom<U> for T where
U: Into<T>, [src]type Error = InfallibleThe type returned in the event of a conversion error.
-pub fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]impl<T, U> TryInto<U> for T where
U: TryFrom<T>, [src]Numeric item types. -They have associated formatting width (FW) and parsing width (PW).
-The formatting width is the minimal width to be formatted.
-If the number is too short, and the padding is not Pad::None,
-then it is left-padded.
-If the number is too long or (in some cases) negative, it is printed as is.
The parsing width is the maximal width to be scanned. -The parser only tries to consume from one to given number of digits (greedily). -It also trims the preceding whitespace if any. -It cannot parse the negative number, so some date and time cannot be formatted then -parsed with the same formatting items.
-Full Gregorian year (FW=4, PW=∞). -May accept years before 1 BCE or after 9999 CE, given an initial sign.
-Gregorian year divided by 100 (century number; FW=PW=2). Implies the non-negative year.
-Gregorian year modulo 100 (FW=PW=2). Cannot be negative.
-Year in the ISO week date (FW=4, PW=∞). -May accept years before 1 BCE or after 9999 CE, given an initial sign.
-Year in the ISO week date, divided by 100 (FW=PW=2). Implies the non-negative year.
-Year in the ISO week date, modulo 100 (FW=PW=2). Cannot be negative.
-Month (FW=PW=2).
-Day of the month (FW=PW=2).
-Week number, where the week 1 starts at the first Sunday of January (FW=PW=2).
-Week number, where the week 1 starts at the first Monday of January (FW=PW=2).
-Week number in the ISO week date (FW=PW=2).
-Day of the week, where Sunday = 0 and Saturday = 6 (FW=PW=1).
-Day of the week, where Monday = 1 and Sunday = 7 (FW=PW=1).
-Day of the year (FW=PW=3).
-Hour number in the 24-hour clocks (FW=PW=2).
-Hour number in the 12-hour clocks (FW=PW=2).
-The number of minutes since the last whole hour (FW=PW=2).
-The number of seconds since the last whole minute (FW=PW=2).
-The number of nanoseconds since the last whole second (FW=PW=9).
-Note that this is not left-aligned;
-see also Fixed::Nanosecond.
The number of non-leap seconds since the midnight UTC on January 1, 1970 (FW=1, PW=∞). -For formatting, it assumes UTC upon the absence of time zone offset.
-Internal(InternalNumeric)Internal uses only.
-This item exists so that one can add additional internal-only formatting -without breaking major compatibility (as enum variants cannot be selectively private).
-impl Clone for Numeric[src]impl Debug for Numeric[src]impl Eq for Numeric[src]impl PartialEq<Numeric> for Numeric[src]impl StructuralEq for Numeric[src]impl StructuralPartialEq for Numeric[src]impl RefUnwindSafe for Numeric[src]impl Send for Numeric[src]impl Sync for Numeric[src]impl Unpin for Numeric[src]impl UnwindSafe for Numeric[src]impl<T> Any for T where
T: 'static + ?Sized, [src]impl<T> Borrow<T> for T where
T: ?Sized, [src]impl<T> BorrowMut<T> for T where
T: ?Sized, [src]pub fn borrow_mut(&mut self) -> &mut T[src]impl<T> From<T> for T[src]impl<T, U> Into<U> for T where
U: From<T>, [src]impl<T> ToOwned for T where
T: Clone, [src]type Owned = TThe resulting type after obtaining ownership.
-pub fn to_owned(&self) -> T[src]pub fn clone_into(&self, target: &mut T)[src]impl<T, U> TryFrom<U> for T where
U: Into<T>, [src]type Error = InfallibleThe type returned in the event of a conversion error.
-pub fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]impl<T, U> TryInto<U> for T where
U: TryFrom<T>, [src]Padding characters for numeric items.
-No padding.
-Zero (0) padding.
Space padding.
-impl Clone for Pad[src]impl Copy for Pad[src]impl Debug for Pad[src]impl Eq for Pad[src]impl PartialEq<Pad> for Pad[src]impl StructuralEq for Pad[src]impl StructuralPartialEq for Pad[src]impl RefUnwindSafe for Pad[src]impl Send for Pad[src]impl Sync for Pad[src]impl Unpin for Pad[src]impl UnwindSafe for Pad[src]impl<T> Any for T where
T: 'static + ?Sized, [src]impl<T> Borrow<T> for T where
T: ?Sized, [src]impl<T> BorrowMut<T> for T where
T: ?Sized, [src]pub fn borrow_mut(&mut self) -> &mut T[src]impl<T> From<T> for T[src]impl<T, U> Into<U> for T where
U: From<T>, [src]impl<T> ToOwned for T where
T: Clone, [src]type Owned = TThe resulting type after obtaining ownership.
-pub fn to_owned(&self) -> T[src]pub fn clone_into(&self, target: &mut T)[src]impl<T, U> TryFrom<U> for T where
U: Into<T>, [src]type Error = InfallibleThe type returned in the event of a conversion error.
-pub fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]impl<T, U> TryInto<U> for T where
U: TryFrom<T>, [src]pub fn format<'a, I, B>(
w: &mut Formatter<'_>,
date: Option<&NaiveDate>,
time: Option<&NaiveTime>,
off: Option<&(String, FixedOffset)>,
items: I
) -> Result where
I: Iterator<Item = B> + Clone,
B: Borrow<Item<'a>>,
Tries to format given arguments with given formatting items.
-Internally used by DelayedFormat.
pub fn format_item<'a>(
w: &mut Formatter<'_>,
date: Option<&NaiveDate>,
time: Option<&NaiveTime>,
off: Option<&(String, FixedOffset)>,
item: &Item<'a>
) -> Result
Formats single formatting item
-pub fn parse<'a, I, B>(
parsed: &mut Parsed,
s: &str,
items: I
) -> ParseResult<()> where
I: Iterator<Item = B>,
B: Borrow<Item<'a>>,
Tries to parse given string into parsed with given formatting items.
-Returns Ok when the entire string has been parsed (otherwise parsed should not be used).
-There should be no trailing string after parsing;
-use a stray Item::Space to trim whitespaces.
This particular date and time parser is:
-Greedy. It will consume the longest possible prefix.
-For example, April is always consumed entirely when the long month name is requested;
-it equally accepts Apr, but prefers the longer prefix in this case.
Padding-agnostic (for numeric items).
-The Pad field is completely ignored,
-so one can prepend any number of whitespace then any number of zeroes before numbers.
(Still) obeying the intrinsic parsing width. This allows, for example, parsing HHMMSS.
Formatting (and parsing) utilities for date and time.
-This module provides the common types and routines to implement,
-for example, DateTime::format or
-DateTime::parse_from_str methods.
-For most cases you should use these high-level interfaces.
Internally the formatting and parsing shares the same abstract formatting items,
-which are just an Iterator of
-the Item type.
-They are generated from more readable format strings;
-currently Chrono supports one built-in syntax closely resembling
-C's strftime format.
pub use self::strftime::StrftimeItems; |
| strftime |
|
| DelayedFormat | A temporary object which can be used as an argument to |
| InternalFixed | An opaque type representing fixed-format item types for internal uses only. - |
| InternalNumeric | An opaque type representing numeric item types for internal uses only. - |
| ParseError | An error from the |
| Parsed | Parsed parts of date and time. There are two classes of methods: - |
| Fixed | Fixed-format item types. - |
| Item | A single formatting item. This is used for both formatting and parsing. - |
| Numeric | Numeric item types. -They have associated formatting width (FW) and parsing width (PW). - |
| Pad | Padding characters for numeric items. - |
| format | Tries to format given arguments with given formatting items.
-Internally used by |
| format_item | Formats single formatting item - |
| parse | Tries to parse given string into |
| ParseResult | Same as |
Redirecting to ../../../chrono/format/fn.parse.html...
- - - \ No newline at end of file diff --git a/docs/chrono/format/parsed/struct.Parsed.html b/docs/chrono/format/parsed/struct.Parsed.html deleted file mode 100644 index 922046fc..00000000 --- a/docs/chrono/format/parsed/struct.Parsed.html +++ /dev/null @@ -1,10 +0,0 @@ - - - - - - -Redirecting to ../../../chrono/format/struct.Parsed.html...
- - - \ No newline at end of file diff --git a/docs/chrono/format/sidebar-items.js b/docs/chrono/format/sidebar-items.js deleted file mode 100644 index 3e16119b..00000000 --- a/docs/chrono/format/sidebar-items.js +++ /dev/null @@ -1 +0,0 @@ -initSidebarItems({"enum":[["Fixed","Fixed-format item types."],["Item","A single formatting item. This is used for both formatting and parsing."],["Numeric","Numeric item types. They have associated formatting width (FW) and parsing width (PW)."],["Pad","Padding characters for numeric items."]],"fn":[["format","Tries to format given arguments with given formatting items. Internally used by `DelayedFormat`."],["format_item","Formats single formatting item"],["parse","Tries to parse given string into `parsed` with given formatting items. Returns `Ok` when the entire string has been parsed (otherwise `parsed` should not be used). There should be no trailing string after parsing; use a stray `Item::Space` to trim whitespaces."]],"mod":[["strftime","`strftime`/`strptime`-inspired date and time formatting syntax."]],"struct":[["DelayedFormat","A temporary object which can be used as an argument to `format!` or others. This is normally constructed via `format` methods of each date and time type."],["InternalFixed","An opaque type representing fixed-format item types for internal uses only."],["InternalNumeric","An opaque type representing numeric item types for internal uses only."],["ParseError","An error from the `parse` function."],["Parsed","Parsed parts of date and time. There are two classes of methods:"]],"type":[["ParseResult","Same as `Resultstrftime/strptime-inspired date and time formatting syntax.
The following specifiers are available both to formatting and parsing.
-| Spec. | Example | Description |
|---|---|---|
| DATE SPECIFIERS: | ||
%Y | 2001 | The full proleptic Gregorian year, zero-padded to 4 digits. 1 |
%C | 20 | The proleptic Gregorian year divided by 100, zero-padded to 2 digits. 2 |
%y | 01 | The proleptic Gregorian year modulo 100, zero-padded to 2 digits. 2 |
%m | 07 | Month number (01--12), zero-padded to 2 digits. |
%b | Jul | Abbreviated month name. Always 3 letters. |
%B | July | Full month name. Also accepts corresponding abbreviation in parsing. |
%h | Jul | Same as %b. |
%d | 08 | Day number (01--31), zero-padded to 2 digits. |
%e | 8 | Same as %d but space-padded. Same as %_d. |
%a | Sun | Abbreviated weekday name. Always 3 letters. |
%A | Sunday | Full weekday name. Also accepts corresponding abbreviation in parsing. |
%w | 0 | Sunday = 0, Monday = 1, ..., Saturday = 6. |
%u | 7 | Monday = 1, Tuesday = 2, ..., Sunday = 7. (ISO 8601) |
%U | 28 | Week number starting with Sunday (00--53), zero-padded to 2 digits. 3 |
%W | 27 | Same as %U, but week 1 starts with the first Monday in that year instead. |
%G | 2001 | Same as %Y but uses the year number in ISO 8601 week date. 4 |
%g | 01 | Same as %y but uses the year number in ISO 8601 week date. 4 |
%V | 27 | Same as %U but uses the week number in ISO 8601 week date (01--53). 4 |
%j | 189 | Day of the year (001--366), zero-padded to 3 digits. |
%D | 07/08/01 | Month-day-year format. Same as %m/%d/%y. |
%x | 07/08/01 | Locale's date representation (e.g., 12/31/99). |
%F | 2001-07-08 | Year-month-day format (ISO 8601). Same as %Y-%m-%d. |
%v | 8-Jul-2001 | Day-month-year format. Same as %e-%b-%Y. |
| TIME SPECIFIERS: | ||
%H | 00 | Hour number (00--23), zero-padded to 2 digits. |
%k | 0 | Same as %H but space-padded. Same as %_H. |
%I | 12 | Hour number in 12-hour clocks (01--12), zero-padded to 2 digits. |
%l | 12 | Same as %I but space-padded. Same as %_I. |
%P | am | am or pm in 12-hour clocks. |
%p | AM | AM or PM in 12-hour clocks. |
%M | 34 | Minute number (00--59), zero-padded to 2 digits. |
%S | 60 | Second number (00--60), zero-padded to 2 digits. 5 |
%f | 026490000 | The fractional seconds (in nanoseconds) since last whole second. 6 |
%.f | .026490 | Similar to .%f but left-aligned. These all consume the leading dot. 6 |
%.3f | .026 | Similar to .%f but left-aligned but fixed to a length of 3. 6 |
%.6f | .026490 | Similar to .%f but left-aligned but fixed to a length of 6. 6 |
%.9f | .026490000 | Similar to .%f but left-aligned but fixed to a length of 9. 6 |
%3f | 026 | Similar to %.3f but without the leading dot. 6 |
%6f | 026490 | Similar to %.6f but without the leading dot. 6 |
%9f | 026490000 | Similar to %.9f but without the leading dot. 6 |
%R | 00:34 | Hour-minute format. Same as %H:%M. |
%T | 00:34:60 | Hour-minute-second format. Same as %H:%M:%S. |
%X | 00:34:60 | Locale's time representation (e.g., 23:13:48). |
%r | 12:34:60 AM | Hour-minute-second format in 12-hour clocks. Same as %I:%M:%S %p. |
| TIME ZONE SPECIFIERS: | ||
%Z | ACST | Local time zone name. Skips all non-whitespace characters during parsing. 7 |
%z | +0930 | Offset from the local time to UTC (with UTC being +0000). |
%:z | +09:30 | Same as %z but with a colon. |
%#z | +09 | Parsing only: Same as %z but allows minutes to be missing or present. |
| DATE & TIME SPECIFIERS: | ||
%c | Sun Jul 8 00:34:60 2001 | Locale's date and time (e.g., Thu Mar 3 23:05:25 2005). |
%+ | 2001-07-08T00:34:60.026490+09:30 | ISO 8601 / RFC 3339 date & time format. 8 |
%s | 994518299 | UNIX timestamp, the number of seconds since 1970-01-01 00:00 UTC. 9 |
| SPECIAL SPECIFIERS: | ||
%t | Literal tab (\t). | |
%n | Literal newline (\n). | |
%% | Literal percent sign. |
It is possible to override the default padding behavior of numeric specifiers %?.
-This is not allowed for other specifiers and will result in the BAD_FORMAT error.
| Modifier | Description |
|---|---|
%-? | Suppresses any padding including spaces and zeroes. (e.g. %j = 012, %-j = 12) |
%_? | Uses spaces as a padding. (e.g. %j = 012, %_j = 12) |
%0? | Uses zeroes as a padding. (e.g. %e = 9, %0e = 09) |
Notes:
-%Y:
-Negative years are allowed in formatting but not in parsing. ↩
%C, %y:
-This is floor division, so 100 BCE (year number -99) will print -1 and 99 respectively. ↩
%U:
-Week 1 starts with the first Sunday in that year.
-It is possible to have week 0 for days before the first Sunday. ↩
%G, %g, %V:
-Week 1 is the first week with at least 4 days in that year.
-Week 0 does not exist, so this should be used with %G or %g. ↩
%S:
-It accounts for leap seconds, so 60 is possible. ↩
%f, %.f, %.3f, %.6f, %.9f, %3f, %6f, %9f:
-
-The default %f is right-aligned and always zero-padded to 9 digits
-for the compatibility with glibc and others,
-so it always counts the number of nanoseconds since the last whole second.
-E.g. 7ms after the last second will print 007000000,
-and parsing 7000000 will yield the same.
-
-
-The variant %.f is left-aligned and print 0, 3, 6 or 9 fractional digits
-according to the precision.
-E.g. 70ms after the last second under %.f will print .070 (note: not .07),
-and parsing .07, .070000 etc. will yield the same.
-Note that they can print or read nothing if the fractional part is zero or
-the next character is not ..
-
-
-The variant %.3f, %.6f and %.9f are left-aligned and print 3, 6 or 9 fractional digits
-according to the number preceding f.
-E.g. 70ms after the last second under %.3f will print .070 (note: not .07),
-and parsing .07, .070000 etc. will yield the same.
-Note that they can read nothing if the fractional part is zero or
-the next character is not . however will print with the specified length.
-
-
-The variant %3f, %6f and %9f are left-aligned and print 3, 6 or 9 fractional digits
-according to the number preceding f, but without the leading dot.
-E.g. 70ms after the last second under %3f will print 070 (note: not 07),
-and parsing 07, 070000 etc. will yield the same.
-Note that they can read nothing if the fractional part is zero. ↩
%Z:
-Offset will not be populated from the parsed data, nor will it be validated.
-Timezone is completely ignored. Similar to the glibc strptime treatment of
-this format code.
-
-
-It is not possible to reliably convert from an abbreviation to an offset,
-for example CDT can mean either Central Daylight Time (North America) or
-China Daylight Time. ↩
%+: Same as %Y-%m-%dT%H:%M:%S%.f%:z, i.e. 0, 3, 6 or 9 fractional
-digits for seconds and colons in the time zone offset.
-
-
-The typical strftime implementations have different (and locale-dependent)
-formats for this specifier. While Chrono's format for %+ is far more
-stable, it is best to avoid this specifier if you want to control the exact
-output. ↩
%s:
-This is not padded and can be negative.
-For the purpose of Chrono, it only accounts for non-leap seconds
-so it slightly differs from ISO C strftime behavior. ↩
| StrftimeItems | Parsing iterator for |
Parsing iterator for strftime-like format strings.
impl<'a> StrftimeItems<'a>[src]pub fn new(s: &'a str) -> StrftimeItems<'a>ⓘNotable traits for StrftimeItems<'a>
impl<'a> Iterator for StrftimeItems<'a> type Item = Item<'a>;[src]Creates a new parsing iterator from the strftime-like format string.
impl<'a> Clone for StrftimeItems<'a>[src]fn clone(&self) -> StrftimeItems<'a>ⓘNotable traits for StrftimeItems<'a>
impl<'a> Iterator for StrftimeItems<'a> type Item = Item<'a>;[src]pub fn clone_from(&mut self, source: &Self)1.0.0[src]impl<'a> Debug for StrftimeItems<'a>[src]impl<'a> Iterator for StrftimeItems<'a>[src]type Item = Item<'a>The type of the elements being iterated over.
-fn next(&mut self) -> Option<Item<'a>>[src]pub fn size_hint(&self) -> (usize, Option<usize>)1.0.0[src]pub fn count(self) -> usize1.0.0[src]pub fn last(self) -> Option<Self::Item>1.0.0[src]pub fn advance_by(&mut self, n: usize) -> Result<(), usize>[src]pub fn nth(&mut self, n: usize) -> Option<Self::Item>1.0.0[src]pub fn step_by(self, step: usize) -> StepBy<Self>1.28.0[src]pub fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter> where
U: IntoIterator<Item = Self::Item>, 1.0.0[src]pub fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter> where
U: IntoIterator, 1.0.0[src]pub fn map<B, F>(self, f: F) -> Map<Self, F> where
F: FnMut(Self::Item) -> B, 1.0.0[src]pub fn for_each<F>(self, f: F) where
F: FnMut(Self::Item), 1.21.0[src]pub fn filter<P>(self, predicate: P) -> Filter<Self, P> where
P: FnMut(&Self::Item) -> bool, 1.0.0[src]pub fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F> where
F: FnMut(Self::Item) -> Option<B>, 1.0.0[src]pub fn enumerate(self) -> Enumerate<Self>1.0.0[src]pub fn peekable(self) -> Peekable<Self>1.0.0[src]pub fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P> where
P: FnMut(&Self::Item) -> bool, 1.0.0[src]pub fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P> where
P: FnMut(&Self::Item) -> bool, 1.0.0[src]pub fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P> where
P: FnMut(Self::Item) -> Option<B>, [src]pub fn skip(self, n: usize) -> Skip<Self>1.0.0[src]pub fn take(self, n: usize) -> Take<Self>1.0.0[src]pub fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F> where
F: FnMut(&mut St, Self::Item) -> Option<B>, 1.0.0[src]pub fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F> where
U: IntoIterator,
F: FnMut(Self::Item) -> U, 1.0.0[src]pub fn flatten(self) -> Flatten<Self> where
Self::Item: IntoIterator, 1.29.0[src]pub fn fuse(self) -> Fuse<Self>1.0.0[src]pub fn inspect<F>(self, f: F) -> Inspect<Self, F> where
F: FnMut(&Self::Item), 1.0.0[src]pub fn by_ref(&mut self) -> &mut Self1.0.0[src]#[must_use =
- "if you really need to exhaust the iterator, consider `.for_each(drop)` instead"]pub fn collect<B>(self) -> B where
B: FromIterator<Self::Item>, 1.0.0[src]pub fn partition<B, F>(self, f: F) -> (B, B) where
F: FnMut(&Self::Item) -> bool,
B: Default + Extend<Self::Item>, 1.0.0[src]pub fn partition_in_place<'a, T, P>(self, predicate: P) -> usize where
Self: DoubleEndedIterator<Item = &'a mut T>,
T: 'a,
P: FnMut(&T) -> bool, [src]pub fn is_partitioned<P>(self, predicate: P) -> bool where
P: FnMut(Self::Item) -> bool, [src]pub fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R where
F: FnMut(B, Self::Item) -> R,
R: Try<Ok = B>, 1.27.0[src]pub fn try_for_each<F, R>(&mut self, f: F) -> R where
F: FnMut(Self::Item) -> R,
R: Try<Ok = ()>, 1.27.0[src]pub fn fold<B, F>(self, init: B, f: F) -> B where
F: FnMut(B, Self::Item) -> B, 1.0.0[src]pub fn fold_first<F>(self, f: F) -> Option<Self::Item> where
F: FnMut(Self::Item, Self::Item) -> Self::Item, [src]pub fn all<F>(&mut self, f: F) -> bool where
F: FnMut(Self::Item) -> bool, 1.0.0[src]pub fn any<F>(&mut self, f: F) -> bool where
F: FnMut(Self::Item) -> bool, 1.0.0[src]pub fn find<P>(&mut self, predicate: P) -> Option<Self::Item> where
P: FnMut(&Self::Item) -> bool, 1.0.0[src]pub fn find_map<B, F>(&mut self, f: F) -> Option<B> where
F: FnMut(Self::Item) -> Option<B>, 1.30.0[src]pub fn try_find<F, R>(
&mut self,
f: F
) -> Result<Option<Self::Item>, <R as Try>::Error> where
F: FnMut(&Self::Item) -> R,
R: Try<Ok = bool>, [src]pub fn position<P>(&mut self, predicate: P) -> Option<usize> where
P: FnMut(Self::Item) -> bool, 1.0.0[src]pub fn rposition<P>(&mut self, predicate: P) -> Option<usize> where
Self: ExactSizeIterator + DoubleEndedIterator,
P: FnMut(Self::Item) -> bool, 1.0.0[src]pub fn max(self) -> Option<Self::Item> where
Self::Item: Ord, 1.0.0[src]pub fn min(self) -> Option<Self::Item> where
Self::Item: Ord, 1.0.0[src]pub fn max_by_key<B, F>(self, f: F) -> Option<Self::Item> where
F: FnMut(&Self::Item) -> B,
B: Ord, 1.6.0[src]pub fn max_by<F>(self, compare: F) -> Option<Self::Item> where
F: FnMut(&Self::Item, &Self::Item) -> Ordering, 1.15.0[src]pub fn min_by_key<B, F>(self, f: F) -> Option<Self::Item> where
F: FnMut(&Self::Item) -> B,
B: Ord, 1.6.0[src]pub fn min_by<F>(self, compare: F) -> Option<Self::Item> where
F: FnMut(&Self::Item, &Self::Item) -> Ordering, 1.15.0[src]pub fn rev(self) -> Rev<Self> where
Self: DoubleEndedIterator, 1.0.0[src]pub fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB) where
Self: Iterator<Item = (A, B)>,
FromA: Default + Extend<A>,
FromB: Default + Extend<B>, 1.0.0[src]pub fn copied<'a, T>(self) -> Copied<Self> where
Self: Iterator<Item = &'a T>,
T: 'a + Copy, 1.36.0[src]pub fn cloned<'a, T>(self) -> Cloned<Self> where
Self: Iterator<Item = &'a T>,
T: 'a + Clone, 1.0.0[src]pub fn cycle(self) -> Cycle<Self> where
Self: Clone, 1.0.0[src]pub fn sum<S>(self) -> S where
S: Sum<Self::Item>, 1.11.0[src]pub fn product<P>(self) -> P where
P: Product<Self::Item>, 1.11.0[src]pub fn cmp<I>(self, other: I) -> Ordering where
I: IntoIterator<Item = Self::Item>,
Self::Item: Ord, 1.5.0[src]pub fn cmp_by<I, F>(self, other: I, cmp: F) -> Ordering where
F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Ordering,
I: IntoIterator, [src]pub fn partial_cmp<I>(self, other: I) -> Option<Ordering> where
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>, 1.5.0[src]pub fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering> where
F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,
I: IntoIterator, [src]pub fn eq<I>(self, other: I) -> bool where
I: IntoIterator,
Self::Item: PartialEq<<I as IntoIterator>::Item>, 1.5.0[src]pub fn eq_by<I, F>(self, other: I, eq: F) -> bool where
F: FnMut(Self::Item, <I as IntoIterator>::Item) -> bool,
I: IntoIterator, [src]pub fn ne<I>(self, other: I) -> bool where
I: IntoIterator,
Self::Item: PartialEq<<I as IntoIterator>::Item>, 1.5.0[src]pub fn lt<I>(self, other: I) -> bool where
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>, 1.5.0[src]pub fn le<I>(self, other: I) -> bool where
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>, 1.5.0[src]pub fn gt<I>(self, other: I) -> bool where
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>, 1.5.0[src]pub fn ge<I>(self, other: I) -> bool where
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>, 1.5.0[src]pub fn is_sorted(self) -> bool where
Self::Item: PartialOrd<Self::Item>, [src]pub fn is_sorted_by<F>(self, compare: F) -> bool where
F: FnMut(&Self::Item, &Self::Item) -> Option<Ordering>, [src]pub fn is_sorted_by_key<F, K>(self, f: F) -> bool where
F: FnMut(Self::Item) -> K,
K: PartialOrd<K>, [src]impl<'a> RefUnwindSafe for StrftimeItems<'a>[src]impl<'a> Send for StrftimeItems<'a>[src]impl<'a> Sync for StrftimeItems<'a>[src]impl<'a> Unpin for StrftimeItems<'a>[src]impl<'a> UnwindSafe for StrftimeItems<'a>[src]impl<T> Any for T where
T: 'static + ?Sized, [src]impl<T> Borrow<T> for T where
T: ?Sized, [src]impl<T> BorrowMut<T> for T where
T: ?Sized, [src]pub fn borrow_mut(&mut self) -> &mut T[src]impl<T> From<T> for T[src]impl<T, U> Into<U> for T where
U: From<T>, [src]impl<I> IntoIterator for I where
I: Iterator, [src]type Item = <I as Iterator>::ItemThe type of the elements being iterated over.
-type IntoIter = IWhich kind of iterator are we turning this into?
-pub fn into_iter(self) -> I[src]impl<T> ToOwned for T where
T: Clone, [src]type Owned = TThe resulting type after obtaining ownership.
-pub fn to_owned(&self) -> T[src]pub fn clone_into(&self, target: &mut T)[src]impl<T, U> TryFrom<U> for T where
U: Into<T>, [src]type Error = InfallibleThe type returned in the event of a conversion error.
-pub fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]impl<T, U> TryInto<U> for T where
U: TryFrom<T>, [src]A temporary object which can be used as an argument to format! or others.
-This is normally constructed via format methods of each date and time type.
impl<'a, I: Iterator<Item = B> + Clone, B: Borrow<Item<'a>>> DelayedFormat<I>[src]pub fn new(
date: Option<NaiveDate>,
time: Option<NaiveTime>,
items: I
) -> DelayedFormat<I>[src]Makes a new DelayedFormat value out of local date and time.
pub fn new_with_offset<Off>(
date: Option<NaiveDate>,
time: Option<NaiveTime>,
offset: &Off,
items: I
) -> DelayedFormat<I> where
Off: Offset + Display, [src]Makes a new DelayedFormat value out of local date and time and UTC offset.
impl<I: Debug> Debug for DelayedFormat<I>[src]impl<'a, I: Iterator<Item = B> + Clone, B: Borrow<Item<'a>>> Display for DelayedFormat<I>[src]impl<I> RefUnwindSafe for DelayedFormat<I> where
I: RefUnwindSafe, [src]impl<I> Send for DelayedFormat<I> where
I: Send, [src]impl<I> Sync for DelayedFormat<I> where
I: Sync, [src]impl<I> Unpin for DelayedFormat<I> where
I: Unpin, [src]impl<I> UnwindSafe for DelayedFormat<I> where
I: UnwindSafe, [src]impl<T> Any for T where
T: 'static + ?Sized, [src]impl<T> Borrow<T> for T where
T: ?Sized, [src]impl<T> BorrowMut<T> for T where
T: ?Sized, [src]pub fn borrow_mut(&mut self) -> &mut T[src]impl<T> From<T> for T[src]impl<T, U> Into<U> for T where
U: From<T>, [src]impl<T> ToString for T where
T: Display + ?Sized, [src]impl<T, U> TryFrom<U> for T where
U: Into<T>, [src]type Error = InfallibleThe type returned in the event of a conversion error.
-pub fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]impl<T, U> TryInto<U> for T where
U: TryFrom<T>, [src]An opaque type representing fixed-format item types for internal uses only.
-impl Clone for InternalFixed[src]fn clone(&self) -> InternalFixed[src]pub fn clone_from(&mut self, source: &Self)1.0.0[src]impl Debug for InternalFixed[src]impl Eq for InternalFixed[src]impl PartialEq<InternalFixed> for InternalFixed[src]fn eq(&self, other: &InternalFixed) -> bool[src]fn ne(&self, other: &InternalFixed) -> bool[src]impl StructuralEq for InternalFixed[src]impl StructuralPartialEq for InternalFixed[src]impl RefUnwindSafe for InternalFixed[src]impl Send for InternalFixed[src]impl Sync for InternalFixed[src]impl Unpin for InternalFixed[src]impl UnwindSafe for InternalFixed[src]impl<T> Any for T where
T: 'static + ?Sized, [src]impl<T> Borrow<T> for T where
T: ?Sized, [src]impl<T> BorrowMut<T> for T where
T: ?Sized, [src]pub fn borrow_mut(&mut self) -> &mut T[src]impl<T> From<T> for T[src]impl<T, U> Into<U> for T where
U: From<T>, [src]impl<T> ToOwned for T where
T: Clone, [src]type Owned = TThe resulting type after obtaining ownership.
-pub fn to_owned(&self) -> T[src]pub fn clone_into(&self, target: &mut T)[src]impl<T, U> TryFrom<U> for T where
U: Into<T>, [src]type Error = InfallibleThe type returned in the event of a conversion error.
-pub fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]impl<T, U> TryInto<U> for T where
U: TryFrom<T>, [src]An opaque type representing numeric item types for internal uses only.
-impl Clone for InternalNumeric[src]fn clone(&self) -> Self[src]pub fn clone_from(&mut self, source: &Self)1.0.0[src]impl Debug for InternalNumeric[src]impl Eq for InternalNumeric[src]impl PartialEq<InternalNumeric> for InternalNumeric[src]impl RefUnwindSafe for InternalNumeric[src]impl Send for InternalNumeric[src]impl Sync for InternalNumeric[src]impl Unpin for InternalNumeric[src]impl UnwindSafe for InternalNumeric[src]impl<T> Any for T where
T: 'static + ?Sized, [src]impl<T> Borrow<T> for T where
T: ?Sized, [src]impl<T> BorrowMut<T> for T where
T: ?Sized, [src]pub fn borrow_mut(&mut self) -> &mut T[src]impl<T> From<T> for T[src]impl<T, U> Into<U> for T where
U: From<T>, [src]impl<T> ToOwned for T where
T: Clone, [src]type Owned = TThe resulting type after obtaining ownership.
-pub fn to_owned(&self) -> T[src]pub fn clone_into(&self, target: &mut T)[src]impl<T, U> TryFrom<U> for T where
U: Into<T>, [src]type Error = InfallibleThe type returned in the event of a conversion error.
-pub fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]impl<T, U> TryInto<U> for T where
U: TryFrom<T>, [src]An error from the parse function.
impl Clone for ParseError[src]fn clone(&self) -> ParseError[src]pub fn clone_from(&mut self, source: &Self)1.0.0[src]impl Copy for ParseError[src]impl Debug for ParseError[src]impl Display for ParseError[src]impl Eq for ParseError[src]impl Error for ParseError[src]fn description(&self) -> &str[src]pub fn source(&self) -> Option<&(dyn Error + 'static)>1.30.0[src]pub fn backtrace(&self) -> Option<&Backtrace>[src]pub fn cause(&self) -> Option<&dyn Error>1.0.0[src]impl PartialEq<ParseError> for ParseError[src]fn eq(&self, other: &ParseError) -> bool[src]fn ne(&self, other: &ParseError) -> bool[src]impl StructuralEq for ParseError[src]impl StructuralPartialEq for ParseError[src]impl RefUnwindSafe for ParseError[src]impl Send for ParseError[src]impl Sync for ParseError[src]impl Unpin for ParseError[src]impl UnwindSafe for ParseError[src]impl<T> Any for T where
T: 'static + ?Sized, [src]impl<T> Borrow<T> for T where
T: ?Sized, [src]impl<T> BorrowMut<T> for T where
T: ?Sized, [src]pub fn borrow_mut(&mut self) -> &mut T[src]impl<T> From<T> for T[src]impl<T, U> Into<U> for T where
U: From<T>, [src]impl<T> ToOwned for T where
T: Clone, [src]type Owned = TThe resulting type after obtaining ownership.
-pub fn to_owned(&self) -> T[src]pub fn clone_into(&self, target: &mut T)[src]impl<T> ToString for T where
T: Display + ?Sized, [src]impl<T, U> TryFrom<U> for T where
U: Into<T>, [src]type Error = InfallibleThe type returned in the event of a conversion error.
-pub fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]impl<T, U> TryInto<U> for T where
U: TryFrom<T>, [src]Parsed parts of date and time. There are two classes of methods:
-set_* methods try to set given field(s) while checking for the consistency.
-It may or may not check for the range constraint immediately (for efficiency reasons).
to_* methods try to make a concrete date and time value out of set fields.
-It fully checks any remaining out-of-range conditions and inconsistent/impossible fields.
year: Option<i32>Year.
-This can be negative unlike year_div_100
-and year_mod_100 fields.
year_div_100: Option<i32>Year divided by 100. Implies that the year is >= 1 BCE when set.
-Due to the common usage, if this field is missing but
-year_mod_100 is present,
-it is inferred to 19 when year_mod_100 >= 70 and 20 otherwise.
year_mod_100: Option<i32>Year modulo 100. Implies that the year is >= 1 BCE when set.
-isoyear: Option<i32>Year in the ISO week date.
-This can be negative unlike isoyear_div_100 and
-isoyear_mod_100 fields.
isoyear_div_100: Option<i32>Year in the ISO week date, divided by 100. -Implies that the year is >= 1 BCE when set.
-Due to the common usage, if this field is missing but
-isoyear_mod_100 is present,
-it is inferred to 19 when isoyear_mod_100 >= 70 and 20 otherwise.
isoyear_mod_100: Option<i32>Year in the ISO week date, modulo 100. -Implies that the year is >= 1 BCE when set.
-month: Option<u32>Month (1--12).
-week_from_sun: Option<u32>Week number, where the week 1 starts at the first Sunday of January -(0--53, 1--53 or 1--52 depending on the year).
-week_from_mon: Option<u32>Week number, where the week 1 starts at the first Monday of January -(0--53, 1--53 or 1--52 depending on the year).
-isoweek: Option<u32>ISO week number -(1--52 or 1--53 depending on the year).
-weekday: Option<Weekday>Day of the week.
-ordinal: Option<u32>Day of the year (1--365 or 1--366 depending on the year).
-day: Option<u32>Day of the month (1--28, 1--29, 1--30 or 1--31 depending on the month).
-hour_div_12: Option<u32>Hour number divided by 12 (0--1). 0 indicates AM and 1 indicates PM.
-hour_mod_12: Option<u32>Hour number modulo 12 (0--11).
-minute: Option<u32>Minute number (0--59).
-second: Option<u32>Second number (0--60, accounting for leap seconds).
-nanosecond: Option<u32>The number of nanoseconds since the whole second (0--999,999,999).
-timestamp: Option<i64>The number of non-leap seconds since the midnight UTC on January 1, 1970.
-This can be off by one if second is 60 (a leap second).
offset: Option<i32>Offset from the local time to UTC, in seconds.
-impl Parsed[src]pub fn new() -> Parsed[src]Returns the initial value of parsed parts.
-pub fn set_year(&mut self, value: i64) -> ParseResult<()>[src]Tries to set the year field from given value.
pub fn set_year_div_100(&mut self, value: i64) -> ParseResult<()>[src]Tries to set the year_div_100 field from given value.
pub fn set_year_mod_100(&mut self, value: i64) -> ParseResult<()>[src]Tries to set the year_mod_100 field from given value.
pub fn set_isoyear(&mut self, value: i64) -> ParseResult<()>[src]Tries to set the isoyear field from given value.
pub fn set_isoyear_div_100(&mut self, value: i64) -> ParseResult<()>[src]Tries to set the isoyear_div_100 field from given value.
pub fn set_isoyear_mod_100(&mut self, value: i64) -> ParseResult<()>[src]Tries to set the isoyear_mod_100 field from given value.
pub fn set_month(&mut self, value: i64) -> ParseResult<()>[src]Tries to set the month field from given value.
pub fn set_week_from_sun(&mut self, value: i64) -> ParseResult<()>[src]Tries to set the week_from_sun field from given value.
pub fn set_week_from_mon(&mut self, value: i64) -> ParseResult<()>[src]Tries to set the week_from_mon field from given value.
pub fn set_isoweek(&mut self, value: i64) -> ParseResult<()>[src]Tries to set the isoweek field from given value.
pub fn set_weekday(&mut self, value: Weekday) -> ParseResult<()>[src]Tries to set the weekday field from given value.
pub fn set_ordinal(&mut self, value: i64) -> ParseResult<()>[src]Tries to set the ordinal field from given value.
pub fn set_day(&mut self, value: i64) -> ParseResult<()>[src]Tries to set the day field from given value.
pub fn set_ampm(&mut self, value: bool) -> ParseResult<()>[src]Tries to set the hour_div_12 field from given value.
-(false for AM, true for PM)
pub fn set_hour12(&mut self, value: i64) -> ParseResult<()>[src]Tries to set the hour_mod_12 field from
-given hour number in 12-hour clocks.
pub fn set_hour(&mut self, value: i64) -> ParseResult<()>[src]Tries to set both hour_div_12 and
-hour_mod_12 fields from given value.
pub fn set_minute(&mut self, value: i64) -> ParseResult<()>[src]Tries to set the minute field from given value.
pub fn set_second(&mut self, value: i64) -> ParseResult<()>[src]Tries to set the second field from given value.
pub fn set_nanosecond(&mut self, value: i64) -> ParseResult<()>[src]Tries to set the nanosecond field from given value.
pub fn set_timestamp(&mut self, value: i64) -> ParseResult<()>[src]Tries to set the timestamp field from given value.
pub fn set_offset(&mut self, value: i64) -> ParseResult<()>[src]Tries to set the offset field from given value.
pub fn to_naive_date(&self) -> ParseResult<NaiveDate>[src]Returns a parsed naive date out of given fields.
-This method is able to determine the date from given subset of fields:
-Gregorian year and ISO week date year can have their century number (*_div_100) omitted,
-the two-digit year is used to guess the century number then.
pub fn to_naive_time(&self) -> ParseResult<NaiveTime>[src]Returns a parsed naive time out of given fields.
-This method is able to determine the time from given subset of fields:
-It is able to handle leap seconds when given second is 60.
-pub fn to_naive_datetime_with_offset(
&self,
offset: i32
) -> ParseResult<NaiveDateTime>[src]Returns a parsed naive date and time out of given fields,
-except for the offset field (assumed to have a given value).
-This is required for parsing a local time or other known-timezone inputs.
This method is able to determine the combined date and time
-from date and time fields or a single timestamp field.
-Either way those fields have to be consistent to each other.
pub fn to_fixed_offset(&self) -> ParseResult<FixedOffset>[src]Returns a parsed fixed time zone offset out of given fields.
-pub fn to_datetime(&self) -> ParseResult<DateTime<FixedOffset>>[src]Returns a parsed timezone-aware date and time out of given fields.
-This method is able to determine the combined date and time
-from date and time fields or a single timestamp field,
-plus a time zone offset.
-Either way those fields have to be consistent to each other.
pub fn to_datetime_with_timezone<Tz: TimeZone>(
&self,
tz: &Tz
) -> ParseResult<DateTime<Tz>>[src]Returns a parsed timezone-aware date and time out of given fields,
-with an additional TimeZone used to interpret and validate the local date.
This method is able to determine the combined date and time
-from date and time fields or a single timestamp field,
-plus a time zone offset.
-Either way those fields have to be consistent to each other.
-If parsed fields include an UTC offset, it also has to be consistent to
-offset.
impl Clone for Parsed[src]impl Debug for Parsed[src]impl Default for Parsed[src]impl PartialEq<Parsed> for Parsed[src]impl StructuralPartialEq for Parsed[src]impl RefUnwindSafe for Parsed[src]impl Send for Parsed[src]impl Sync for Parsed[src]impl Unpin for Parsed[src]impl UnwindSafe for Parsed[src]impl<T> Any for T where
T: 'static + ?Sized, [src]impl<T> Borrow<T> for T where
T: ?Sized, [src]impl<T> BorrowMut<T> for T where
T: ?Sized, [src]pub fn borrow_mut(&mut self) -> &mut T[src]impl<T> From<T> for T[src]impl<T, U> Into<U> for T where
U: From<T>, [src]impl<T> ToOwned for T where
T: Clone, [src]type Owned = TThe resulting type after obtaining ownership.
-pub fn to_owned(&self) -> T[src]pub fn clone_into(&self, target: &mut T)[src]impl<T, U> TryFrom<U> for T where
U: Into<T>, [src]type Error = InfallibleThe type returned in the event of a conversion error.
-pub fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]impl<T, U> TryInto<U> for T where
U: TryFrom<T>, [src]type ParseResult<T> = Result<T, ParseError>;
Same as Result<T, ParseError>.
It aims to be a feature-complete superset of -the time library. -In particular,
-There were several previous attempts to bring a good date and time library to Rust, -which Chrono builds upon and should acknowledge:
-Any significant changes to Chrono are documented in
-the CHANGELOG.md file.
Put this in your Cargo.toml:
[dependencies]
-chrono = "0.4"
-Chrono supports various runtime environments and operating systems, and has -several features that may be enabled or disabled.
-Default features:
-alloc: Enable features that depend on allocation (primarily string formatting)std: Enables functionality that depends on the standard library. This
-is a superset of alloc and adds interoperation with standard library types
-and traits.clock: enables reading the system time (now), independent of whether
-std::time::SystemTime is present, depends on having a libc.Optional features:
-wasmbind: Enable integration with wasm-bindgen and its js-sys projectserde: Enable serialization/deserialization via serde.unstable-locales: Enable localization. This adds various methods with a
-_localized suffix. The implementation and API may change or even be
-removed in a patch release. Feedback welcome.See the cargo docs for examples of specifying features.
-Chrono currently uses its own Duration type to represent the magnitude
-of a time span. Since this has the same name as the newer, standard type for
-duration, the reference will refer this type as OldDuration.
Note that this is an "accurate" duration represented as seconds and -nanoseconds and does not represent "nominal" components such as days or -months.
-When the oldtime feature is enabled, Duration is an alias for the
-time::Duration
-type from v0.1 of the time crate. time v0.1 is deprecated, so new code
-should disable the oldtime feature and use the chrono::Duration type
-instead. The oldtime feature is enabled by default for backwards
-compatibility, but future versions of Chrono are likely to remove the
-feature entirely.
Chrono does not yet natively support
-the standard Duration type,
-but it will be supported in the future.
-Meanwhile you can convert between two types with
-Duration::from_std
-and
-Duration::to_std
-methods.
Chrono provides a
-DateTime
-type to represent a date and a time in a timezone.
For more abstract moment-in-time tracking such as internal timekeeping
-that is unconcerned with timezones, consider
-time::SystemTime,
-which tracks your system clock, or
-time::Instant, which
-is an opaque but monotonically-increasing representation of a moment in time.
DateTime is timezone-aware and must be constructed from
-the TimeZone object,
-which defines how the local date is converted to and back from the UTC date.
-There are three well-known TimeZone implementations:
Utc specifies the UTC time zone. It is most efficient.
Local specifies the system local time zone.
FixedOffset specifies
-an arbitrary, fixed time zone such as UTC+09:00 or UTC-10:30.
-This often results from the parsed textual date and time.
-Since it stores the most information and does not depend on the system environment,
-you would want to normalize other TimeZones into this type.
DateTimes with different TimeZone types are distinct and do not mix,
-but can be converted to each other using
-the DateTime::with_timezone method.
You can get the current date and time in the UTC time zone
-(Utc::now())
-or in the local time zone
-(Local::now()).
-use chrono::prelude::*; - -let utc: DateTime<Utc> = Utc::now(); // e.g. `2014-11-28T12:45:59.324310806Z` -let local: DateTime<Local> = Local::now(); // e.g. `2014-11-28T21:45:59.324310806+09:00`
Alternatively, you can create your own date and time. -This is a bit verbose due to Rust's lack of function and method overloading, -but in turn we get a rich combination of initialization methods.
- --use chrono::prelude::*; -use chrono::offset::LocalResult; - -let dt = Utc.ymd(2014, 7, 8).and_hms(9, 10, 11); // `2014-07-08T09:10:11Z` -// July 8 is 188th day of the year 2014 (`o` for "ordinal") -assert_eq!(dt, Utc.yo(2014, 189).and_hms(9, 10, 11)); -// July 8 is Tuesday in ISO week 28 of the year 2014. -assert_eq!(dt, Utc.isoywd(2014, 28, Weekday::Tue).and_hms(9, 10, 11)); - -let dt = Utc.ymd(2014, 7, 8).and_hms_milli(9, 10, 11, 12); // `2014-07-08T09:10:11.012Z` -assert_eq!(dt, Utc.ymd(2014, 7, 8).and_hms_micro(9, 10, 11, 12_000)); -assert_eq!(dt, Utc.ymd(2014, 7, 8).and_hms_nano(9, 10, 11, 12_000_000)); - -// dynamic verification -assert_eq!(Utc.ymd_opt(2014, 7, 8).and_hms_opt(21, 15, 33), - LocalResult::Single(Utc.ymd(2014, 7, 8).and_hms(21, 15, 33))); -assert_eq!(Utc.ymd_opt(2014, 7, 8).and_hms_opt(80, 15, 33), LocalResult::None); -assert_eq!(Utc.ymd_opt(2014, 7, 38).and_hms_opt(21, 15, 33), LocalResult::None); - -// other time zone objects can be used to construct a local datetime. -// obviously, `local_dt` is normally different from `dt`, but `fixed_dt` should be identical. -let local_dt = Local.ymd(2014, 7, 8).and_hms_milli(9, 10, 11, 12); -let fixed_dt = FixedOffset::east(9 * 3600).ymd(2014, 7, 8).and_hms_milli(18, 10, 11, 12); -assert_eq!(dt, fixed_dt);
Various properties are available to the date and time, and can be altered individually.
-Most of them are defined in the traits Datelike and
-Timelike which you should use before.
-Addition and subtraction is also supported.
-The following illustrates most supported operations to the date and time:
- -use chrono::prelude::*; -use chrono::Duration; - -// assume this returned `2014-11-28T21:45:59.324310806+09:00`: -let dt = FixedOffset::east(9*3600).ymd(2014, 11, 28).and_hms_nano(21, 45, 59, 324310806); - -// property accessors -assert_eq!((dt.year(), dt.month(), dt.day()), (2014, 11, 28)); -assert_eq!((dt.month0(), dt.day0()), (10, 27)); // for unfortunate souls -assert_eq!((dt.hour(), dt.minute(), dt.second()), (21, 45, 59)); -assert_eq!(dt.weekday(), Weekday::Fri); -assert_eq!(dt.weekday().number_from_monday(), 5); // Mon=1, ..., Sun=7 -assert_eq!(dt.ordinal(), 332); // the day of year -assert_eq!(dt.num_days_from_ce(), 735565); // the number of days from and including Jan 1, 1 - -// time zone accessor and manipulation -assert_eq!(dt.offset().fix().local_minus_utc(), 9 * 3600); -assert_eq!(dt.timezone(), FixedOffset::east(9 * 3600)); -assert_eq!(dt.with_timezone(&Utc), Utc.ymd(2014, 11, 28).and_hms_nano(12, 45, 59, 324310806)); - -// a sample of property manipulations (validates dynamically) -assert_eq!(dt.with_day(29).unwrap().weekday(), Weekday::Sat); // 2014-11-29 is Saturday -assert_eq!(dt.with_day(32), None); -assert_eq!(dt.with_year(-300).unwrap().num_days_from_ce(), -109606); // November 29, 301 BCE - -// arithmetic operations -let dt1 = Utc.ymd(2014, 11, 14).and_hms(8, 9, 10); -let dt2 = Utc.ymd(2014, 11, 14).and_hms(10, 9, 8); -assert_eq!(dt1.signed_duration_since(dt2), Duration::seconds(-2 * 3600 + 2)); -assert_eq!(dt2.signed_duration_since(dt1), Duration::seconds(2 * 3600 - 2)); -assert_eq!(Utc.ymd(1970, 1, 1).and_hms(0, 0, 0) + Duration::seconds(1_000_000_000), - Utc.ymd(2001, 9, 9).and_hms(1, 46, 40)); -assert_eq!(Utc.ymd(1970, 1, 1).and_hms(0, 0, 0) - Duration::seconds(1_000_000_000), - Utc.ymd(1938, 4, 24).and_hms(22, 13, 20));
Formatting is done via the format method,
-which format is equivalent to the familiar strftime format.
See format::strftime
-documentation for full syntax and list of specifiers.
The default to_string method and {:?} specifier also give a reasonable representation.
-Chrono also provides to_rfc2822 and
-to_rfc3339 methods
-for well-known formats.
Chrono now also provides date formatting in almost any language without the
-help of an additional C library. This functionality is under the feature
-unstable-locales:
chrono { version = "0.4", features = ["unstable-locales"]
-The unstable-locales feature requires and implies at least the alloc feature.
-use chrono::prelude::*; - -let dt = Utc.ymd(2014, 11, 28).and_hms(12, 0, 9); -assert_eq!(dt.format("%Y-%m-%d %H:%M:%S").to_string(), "2014-11-28 12:00:09"); -assert_eq!(dt.format("%a %b %e %T %Y").to_string(), "Fri Nov 28 12:00:09 2014"); -assert_eq!(dt.format_localized("%A %e %B %Y, %T", Locale::fr_BE).to_string(), "vendredi 28 novembre 2014, 12:00:09"); -assert_eq!(dt.format("%a %b %e %T %Y").to_string(), dt.format("%c").to_string()); - -assert_eq!(dt.to_string(), "2014-11-28 12:00:09 UTC"); -assert_eq!(dt.to_rfc2822(), "Fri, 28 Nov 2014 12:00:09 +0000"); -assert_eq!(dt.to_rfc3339(), "2014-11-28T12:00:09+00:00"); -assert_eq!(format!("{:?}", dt), "2014-11-28T12:00:09Z"); - -// Note that milli/nanoseconds are only printed if they are non-zero -let dt_nano = Utc.ymd(2014, 11, 28).and_hms_nano(12, 0, 9, 1); -assert_eq!(format!("{:?}", dt_nano), "2014-11-28T12:00:09.000000001Z");
Parsing can be done with three methods:
-The standard FromStr trait
-(and parse method
-on a string) can be used for parsing DateTime<FixedOffset>, DateTime<Utc> and
-DateTime<Local> values. This parses what the {:?}
-(std::fmt::Debug)
-format specifier prints, and requires the offset to be present.
DateTime::parse_from_str parses
-a date and time with offsets and returns DateTime<FixedOffset>.
-This should be used when the offset is a part of input and the caller cannot guess that.
-It cannot be used when the offset can be missing.
-DateTime::parse_from_rfc2822
-and
-DateTime::parse_from_rfc3339
-are similar but for well-known formats.
Offset::datetime_from_str is
-similar but returns DateTime of given offset.
-When the explicit offset is missing from the input, it simply uses given offset.
-It issues an error when the input contains an explicit offset different
-from the current offset.
More detailed control over the parsing process is available via
-format module.
-use chrono::prelude::*; - -let dt = Utc.ymd(2014, 11, 28).and_hms(12, 0, 9); -let fixed_dt = dt.with_timezone(&FixedOffset::east(9*3600)); - -// method 1 -assert_eq!("2014-11-28T12:00:09Z".parse::<DateTime<Utc>>(), Ok(dt.clone())); -assert_eq!("2014-11-28T21:00:09+09:00".parse::<DateTime<Utc>>(), Ok(dt.clone())); -assert_eq!("2014-11-28T21:00:09+09:00".parse::<DateTime<FixedOffset>>(), Ok(fixed_dt.clone())); - -// method 2 -assert_eq!(DateTime::parse_from_str("2014-11-28 21:00:09 +09:00", "%Y-%m-%d %H:%M:%S %z"), - Ok(fixed_dt.clone())); -assert_eq!(DateTime::parse_from_rfc2822("Fri, 28 Nov 2014 21:00:09 +0900"), - Ok(fixed_dt.clone())); -assert_eq!(DateTime::parse_from_rfc3339("2014-11-28T21:00:09+09:00"), Ok(fixed_dt.clone())); - -// method 3 -assert_eq!(Utc.datetime_from_str("2014-11-28 12:00:09", "%Y-%m-%d %H:%M:%S"), Ok(dt.clone())); -assert_eq!(Utc.datetime_from_str("Fri Nov 28 12:00:09 2014", "%a %b %e %T %Y"), Ok(dt.clone())); - -// oops, the year is missing! -assert!(Utc.datetime_from_str("Fri Nov 28 12:00:09", "%a %b %e %T %Y").is_err()); -// oops, the format string does not include the year at all! -assert!(Utc.datetime_from_str("Fri Nov 28 12:00:09", "%a %b %e %T").is_err()); -// oops, the weekday is incorrect! -assert!(Utc.datetime_from_str("Sat Nov 28 12:00:09 2014", "%a %b %e %T %Y").is_err());
Again : See format::strftime
-documentation for full syntax and list of specifiers.
Use Utc.timestamp(seconds, nanoseconds)
-to construct a DateTime<Utc> from a UNIX timestamp
-(seconds, nanoseconds that passed since January 1st 1970).
Use DateTime.timestamp to get the timestamp (in seconds)
-from a DateTime. Additionally, you can use
-DateTime.timestamp_subsec_nanos
-to get the number of additional number of nanoseconds.
-// We need the trait in scope to use Utc::timestamp(). -use chrono::{DateTime, TimeZone, Utc}; - -// Construct a datetime from epoch: -let dt = Utc.timestamp(1_500_000_000, 0); -assert_eq!(dt.to_rfc2822(), "Fri, 14 Jul 2017 02:40:00 +0000"); - -// Get epoch value from a datetime: -let dt = DateTime::parse_from_rfc2822("Fri, 14 Jul 2017 02:40:00 +0000").unwrap(); -assert_eq!(dt.timestamp(), 1_500_000_000);
Chrono also provides an individual date type (Date).
-It also has time zones attached, and have to be constructed via time zones.
-Most operations available to DateTime are also available to Date whenever appropriate.
-use chrono::prelude::*; -use chrono::offset::LocalResult; - -assert_eq!(Utc::today(), Utc::now().date()); -assert_eq!(Local::today(), Local::now().date()); - -assert_eq!(Utc.ymd(2014, 11, 28).weekday(), Weekday::Fri); -assert_eq!(Utc.ymd_opt(2014, 11, 31), LocalResult::None); -assert_eq!(Utc.ymd(2014, 11, 28).and_hms_milli(7, 8, 9, 10).format("%H%M%S").to_string(), - "070809");
There is no timezone-aware Time due to the lack of usefulness and also the complexity.
DateTime has date method
-which returns a Date which represents its date component.
-There is also a time method,
-which simply returns a naive local time described below.
Chrono provides naive counterparts to Date, (non-existent) Time and DateTime
-as NaiveDate,
-NaiveTime and
-NaiveDateTime respectively.
They have almost equivalent interfaces as their timezone-aware twins, -but are not associated to time zones obviously and can be quite low-level. -They are mostly useful for building blocks for higher-level types.
-Timezone-aware DateTime and Date types have two methods returning naive versions:
-naive_local returns
-a view to the naive local time,
-and naive_utc returns
-a view to the naive UTC time.
Only proleptic Gregorian calendar (i.e. extended to support older dates) is supported. -Be very careful if you really have to deal with pre-20C dates, they can be in Julian or others.
-Date types are limited in about +/- 262,000 years from the common epoch. -Time types are limited in the nanosecond accuracy.
-Leap seconds are supported in the representation but
-Chrono doesn't try to make use of them.
-(The main reason is that leap seconds are not really predictable.)
-Almost every operation over the possible leap seconds will ignore them.
-Consider using NaiveDateTime with the implicit TAI (International Atomic Time) scale
-if you want.
Chrono inherently does not support an inaccurate or partial date and time representation.
-Any operation that can be ambiguous will return None in such cases.
-For example, "a month later" of 2014-01-30 is not well-defined
-and consequently Utc.ymd(2014, 1, 30).with_month(2) returns None.
Non ISO week handling is not yet supported. -For now you can use the chrono_ext -crate (sources).
-Advanced time zone handling is not yet supported. -For now you can try the Chrono-tz crate instead.
-pub use format::ParseError; |
pub use format::ParseResult; |
pub use naive::IsoWeek; |
pub use naive::NaiveDate; |
pub use naive::NaiveDateTime; |
pub use naive::NaiveTime; |
pub use offset::Local; |
pub use offset::FixedOffset; |
pub use offset::LocalResult; |
pub use offset::Offset; |
pub use offset::TimeZone; |
pub use offset::Utc; |
| format | Formatting (and parsing) utilities for date and time. - |
| naive | Date and time types unconcerned with timezones. - |
| offset | The time zone, which calculates offsets from the local time to UTC. - |
| prelude | A convenience module appropriate for glob imports ( |
| Date | ISO 8601 calendar date with time zone. - |
| DateTime | ISO 8601 combined date and time with time zone. - |
| Duration | ISO 8601 time duration with nanosecond precision. -This also allows for the negative duration; see individual methods for details. - |
| ParseMonthError | An error resulting from reading |
| ParseWeekdayError | An error resulting from reading |
| Month | The month of the year. - |
| RoundingError | An error from rounding by |
| SecondsFormat | Specific formatting options for seconds. This may be extended in the -future, so exhaustive matching in external code is not recommended. - |
| Weekday | The day of week. - |
| MAX_DATE | The maximum possible |
| MAX_DATETIME | The maximum possible |
| MIN_DATE | The minimum possible |
| MIN_DATETIME | The minimum possible |
| Datelike | The common set of methods for date component. - |
| DurationRound | Extension trait for rounding or truncating a DateTime by a Duration. - |
| SubsecRound | Extension trait for subsecond rounding or truncation to a maximum number -of digits. Rounding can be used to decrease the error variance when -serializing/persisting to lower precision. Truncation is the default -behavior in Chrono display formatting. Either can be used to guarantee -equality (e.g. for testing) when round-tripping through a lower precision -format. - |
| Timelike | The common set of methods for time component. - |
pub const MAX_DATE: NaiveDate;
The maximum possible NaiveDate (December 31, 262143 CE).
pub const MAX_DATETIME: NaiveDateTime;
The maximum possible NaiveDateTime.
pub const MIN_DATE: NaiveDate;
The minimum possible NaiveDate (January 1, 262145 BCE).
pub const MIN_DATETIME: NaiveDateTime;
The minimum possible NaiveDateTime.
Redirecting to ../../../chrono/naive/constant.MAX_DATE.html...
- - - \ No newline at end of file diff --git a/docs/chrono/naive/date/constant.MIN_DATE.html b/docs/chrono/naive/date/constant.MIN_DATE.html deleted file mode 100644 index f9fa9dcc..00000000 --- a/docs/chrono/naive/date/constant.MIN_DATE.html +++ /dev/null @@ -1,10 +0,0 @@ - - - - - - -Redirecting to ../../../chrono/naive/constant.MIN_DATE.html...
- - - \ No newline at end of file diff --git a/docs/chrono/naive/date/struct.NaiveDate.html b/docs/chrono/naive/date/struct.NaiveDate.html deleted file mode 100644 index 2c1302a0..00000000 --- a/docs/chrono/naive/date/struct.NaiveDate.html +++ /dev/null @@ -1,10 +0,0 @@ - - - - - - -Redirecting to ../../../chrono/naive/struct.NaiveDate.html...
- - - \ No newline at end of file diff --git a/docs/chrono/naive/datetime/constant.MAX_DATETIME.html b/docs/chrono/naive/datetime/constant.MAX_DATETIME.html deleted file mode 100644 index dc4e4111..00000000 --- a/docs/chrono/naive/datetime/constant.MAX_DATETIME.html +++ /dev/null @@ -1,10 +0,0 @@ - - - - - - -Redirecting to ../../../chrono/naive/constant.MAX_DATETIME.html...
- - - \ No newline at end of file diff --git a/docs/chrono/naive/datetime/constant.MIN_DATETIME.html b/docs/chrono/naive/datetime/constant.MIN_DATETIME.html deleted file mode 100644 index e5ac290b..00000000 --- a/docs/chrono/naive/datetime/constant.MIN_DATETIME.html +++ /dev/null @@ -1,10 +0,0 @@ - - - - - - -Redirecting to ../../../chrono/naive/constant.MIN_DATETIME.html...
- - - \ No newline at end of file diff --git a/docs/chrono/naive/datetime/struct.NaiveDateTime.html b/docs/chrono/naive/datetime/struct.NaiveDateTime.html deleted file mode 100644 index 8c2ea7d9..00000000 --- a/docs/chrono/naive/datetime/struct.NaiveDateTime.html +++ /dev/null @@ -1,10 +0,0 @@ - - - - - - -Redirecting to ../../../chrono/naive/struct.NaiveDateTime.html...
- - - \ No newline at end of file diff --git a/docs/chrono/naive/index.html b/docs/chrono/naive/index.html deleted file mode 100644 index 32e02d11..00000000 --- a/docs/chrono/naive/index.html +++ /dev/null @@ -1,22 +0,0 @@ -Date and time types unconcerned with timezones.
-They are primarily building blocks for other types
-(e.g. TimeZone),
-but can be also used for the simpler date and time handling.
| IsoWeek | ISO 8601 week. - |
| NaiveDate | ISO 8601 calendar date without timezone. -Allows for every proleptic Gregorian date -from Jan 1, 262145 BCE to Dec 31, 262143 CE. -Also supports the conversion from ISO 8601 ordinal and week date. - |
| NaiveDateTime | ISO 8601 combined date and time without timezone. - |
| NaiveTime | ISO 8601 time without timezone. -Allows for the nanosecond precision and optional leap second representation. - |
| MAX_DATE | The maximum possible |
| MAX_DATETIME | The maximum possible |
| MIN_DATE | The minimum possible |
| MIN_DATETIME | The minimum possible |
Redirecting to ../../../chrono/naive/struct.IsoWeek.html...
- - - \ No newline at end of file diff --git a/docs/chrono/naive/sidebar-items.js b/docs/chrono/naive/sidebar-items.js deleted file mode 100644 index 392733eb..00000000 --- a/docs/chrono/naive/sidebar-items.js +++ /dev/null @@ -1 +0,0 @@ -initSidebarItems({"constant":[["MAX_DATE","The maximum possible `NaiveDate` (December 31, 262143 CE)."],["MAX_DATETIME","The maximum possible `NaiveDateTime`."],["MIN_DATE","The minimum possible `NaiveDate` (January 1, 262145 BCE)."],["MIN_DATETIME","The minimum possible `NaiveDateTime`."]],"struct":[["IsoWeek","ISO 8601 week."],["NaiveDate","ISO 8601 calendar date without timezone. Allows for every proleptic Gregorian date from Jan 1, 262145 BCE to Dec 31, 262143 CE. Also supports the conversion from ISO 8601 ordinal and week date."],["NaiveDateTime","ISO 8601 combined date and time without timezone."],["NaiveTime","ISO 8601 time without timezone. Allows for the nanosecond precision and optional leap second representation."]]}); \ No newline at end of file diff --git a/docs/chrono/naive/struct.IsoWeek.html b/docs/chrono/naive/struct.IsoWeek.html deleted file mode 100644 index e9487178..00000000 --- a/docs/chrono/naive/struct.IsoWeek.html +++ /dev/null @@ -1,83 +0,0 @@ -ISO 8601 week.
-This type, combined with Weekday,
-constitues the ISO 8601 week date.
-One can retrieve this type from the existing Datelike types
-via the Datelike::iso_week method.
impl IsoWeek[src]pub fn year(&self) -> i32[src]Returns the year number for this ISO week.
--use chrono::{NaiveDate, Datelike, Weekday}; - -let d = NaiveDate::from_isoywd(2015, 1, Weekday::Mon); -assert_eq!(d.iso_week().year(), 2015);
This year number might not match the calendar year number. -Continuing the example...
- --assert_eq!(d.year(), 2014); -assert_eq!(d, NaiveDate::from_ymd(2014, 12, 29));
pub fn week(&self) -> u32[src]Returns the ISO week number starting from 1.
-The return value ranges from 1 to 53. (The last week of year differs by years.)
--use chrono::{NaiveDate, Datelike, Weekday}; - -let d = NaiveDate::from_isoywd(2015, 15, Weekday::Mon); -assert_eq!(d.iso_week().week(), 15);
pub fn week0(&self) -> u32[src]Returns the ISO week number starting from 0.
-The return value ranges from 0 to 52. (The last week of year differs by years.)
--use chrono::{NaiveDate, Datelike, Weekday}; - -let d = NaiveDate::from_isoywd(2015, 15, Weekday::Mon); -assert_eq!(d.iso_week().week0(), 14);
impl Clone for IsoWeek[src]impl Copy for IsoWeek[src]impl Debug for IsoWeek[src]The Debug output of the ISO week w is the same as
-d.format("%G-W%V")
-where d is any NaiveDate value in that week.
-use chrono::{NaiveDate, Datelike}; - -assert_eq!(format!("{:?}", NaiveDate::from_ymd(2015, 9, 5).iso_week()), "2015-W36"); -assert_eq!(format!("{:?}", NaiveDate::from_ymd( 0, 1, 3).iso_week()), "0000-W01"); -assert_eq!(format!("{:?}", NaiveDate::from_ymd(9999, 12, 31).iso_week()), "9999-W52");
ISO 8601 requires an explicit sign for years before 1 BCE or after 9999 CE.
- --assert_eq!(format!("{:?}", NaiveDate::from_ymd( 0, 1, 2).iso_week()), "-0001-W52"); -assert_eq!(format!("{:?}", NaiveDate::from_ymd(10000, 12, 31).iso_week()), "+10000-W52");
impl Eq for IsoWeek[src]impl Ord for IsoWeek[src]fn cmp(&self, other: &IsoWeek) -> Ordering[src]#[must_use]pub fn max(self, other: Self) -> Self1.21.0[src]#[must_use]pub fn min(self, other: Self) -> Self1.21.0[src]#[must_use]pub fn clamp(self, min: Self, max: Self) -> Self1.50.0[src]impl PartialEq<IsoWeek> for IsoWeek[src]impl PartialOrd<IsoWeek> for IsoWeek[src]fn partial_cmp(&self, other: &IsoWeek) -> Option<Ordering>[src]fn lt(&self, other: &IsoWeek) -> bool[src]fn le(&self, other: &IsoWeek) -> bool[src]fn gt(&self, other: &IsoWeek) -> bool[src]fn ge(&self, other: &IsoWeek) -> bool[src]impl StructuralEq for IsoWeek[src]impl StructuralPartialEq for IsoWeek[src]impl RefUnwindSafe for IsoWeek[src]impl Send for IsoWeek[src]impl Sync for IsoWeek[src]impl Unpin for IsoWeek[src]impl UnwindSafe for IsoWeek[src]impl<T> Any for T where
T: 'static + ?Sized, [src]impl<T> Borrow<T> for T where
T: ?Sized, [src]impl<T> BorrowMut<T> for T where
T: ?Sized, [src]pub fn borrow_mut(&mut self) -> &mut T[src]impl<T> From<T> for T[src]impl<T, U> Into<U> for T where
U: From<T>, [src]impl<T> ToOwned for T where
T: Clone, [src]type Owned = TThe resulting type after obtaining ownership.
-pub fn to_owned(&self) -> T[src]pub fn clone_into(&self, target: &mut T)[src]impl<T, U> TryFrom<U> for T where
U: Into<T>, [src]type Error = InfallibleThe type returned in the event of a conversion error.
-pub fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]impl<T, U> TryInto<U> for T where
U: TryFrom<T>, [src]ISO 8601 calendar date without timezone. -Allows for every proleptic Gregorian date -from Jan 1, 262145 BCE to Dec 31, 262143 CE. -Also supports the conversion from ISO 8601 ordinal and week date.
-The ISO 8601 calendar date follows the proleptic Gregorian calendar. -It is like a normal civil calendar but note some slight differences:
-Dates before the Gregorian calendar's inception in 1582 are defined via the extrapolation. -Be careful, as historical dates are often noted in the Julian calendar and others -and the transition to Gregorian may differ across countries (as late as early 20C).
-(Some example: Both Shakespeare from Britain and Cervantes from Spain seemingly died -on the same calendar date---April 23, 1616---but in the different calendar. -Britain used the Julian calendar at that time, so Shakespeare's death is later.)
-ISO 8601 calendars has the year 0, which is 1 BCE (a year before 1 CE).
-If you need a typical BCE/BC and CE/AD notation for year numbers,
-use the Datelike::year_ce method.
The ISO 8601 week date is a triple of year number, week number -and day of the week with the following rules:
-A week consists of Monday through Sunday, and is always numbered within some year. -The week number ranges from 1 to 52 or 53 depending on the year.
-The week 1 of given year is defined as the first week containing January 4 of that year, -or equivalently, the first week containing four or more days in that year.
-The year number in the week date may not correspond to the actual Gregorian year. -For example, January 3, 2016 (Sunday) was on the last (53rd) week of 2015.
-Chrono's date types default to the ISO 8601 calendar date,
-but Datelike::iso_week and
-Datelike::weekday methods
-can be used to get the corresponding week date.
The ISO 8601 ordinal date is a pair of year number and day of the year ("ordinal"). -The ordinal number ranges from 1 to 365 or 366 depending on the year. -The year number is the same as that of the calendar date.
-This is currently the internal format of Chrono's date types.
-impl NaiveDate[src]pub fn from_ymd(year: i32, month: u32, day: u32) -> NaiveDate[src]Makes a new NaiveDate from the calendar date
-(year, month and day).
Panics on the out-of-range date, invalid month and/or day.
--use chrono::{NaiveDate, Datelike, Weekday}; - -let d = NaiveDate::from_ymd(2015, 3, 14); -assert_eq!(d.year(), 2015); -assert_eq!(d.month(), 3); -assert_eq!(d.day(), 14); -assert_eq!(d.ordinal(), 73); // day of year -assert_eq!(d.iso_week().year(), 2015); -assert_eq!(d.iso_week().week(), 11); -assert_eq!(d.weekday(), Weekday::Sat); -assert_eq!(d.num_days_from_ce(), 735671); // days since January 1, 1 CE
pub fn from_ymd_opt(year: i32, month: u32, day: u32) -> Option<NaiveDate>[src]Makes a new NaiveDate from the calendar date
-(year, month and day).
Returns None on the out-of-range date, invalid month and/or day.
-use chrono::NaiveDate; - -let from_ymd_opt = NaiveDate::from_ymd_opt; - -assert!(from_ymd_opt(2015, 3, 14).is_some()); -assert!(from_ymd_opt(2015, 0, 14).is_none()); -assert!(from_ymd_opt(2015, 2, 29).is_none()); -assert!(from_ymd_opt(-4, 2, 29).is_some()); // 5 BCE is a leap year -assert!(from_ymd_opt(400000, 1, 1).is_none()); -assert!(from_ymd_opt(-400000, 1, 1).is_none());
pub fn from_yo(year: i32, ordinal: u32) -> NaiveDate[src]Makes a new NaiveDate from the ordinal date
-(year and day of the year).
Panics on the out-of-range date and/or invalid day of year.
--use chrono::{NaiveDate, Datelike, Weekday}; - -let d = NaiveDate::from_yo(2015, 73); -assert_eq!(d.ordinal(), 73); -assert_eq!(d.year(), 2015); -assert_eq!(d.month(), 3); -assert_eq!(d.day(), 14); -assert_eq!(d.iso_week().year(), 2015); -assert_eq!(d.iso_week().week(), 11); -assert_eq!(d.weekday(), Weekday::Sat); -assert_eq!(d.num_days_from_ce(), 735671); // days since January 1, 1 CE
pub fn from_yo_opt(year: i32, ordinal: u32) -> Option<NaiveDate>[src]Makes a new NaiveDate from the ordinal date
-(year and day of the year).
Returns None on the out-of-range date and/or invalid day of year.
-use chrono::NaiveDate; - -let from_yo_opt = NaiveDate::from_yo_opt; - -assert!(from_yo_opt(2015, 100).is_some()); -assert!(from_yo_opt(2015, 0).is_none()); -assert!(from_yo_opt(2015, 365).is_some()); -assert!(from_yo_opt(2015, 366).is_none()); -assert!(from_yo_opt(-4, 366).is_some()); // 5 BCE is a leap year -assert!(from_yo_opt(400000, 1).is_none()); -assert!(from_yo_opt(-400000, 1).is_none());
pub fn from_isoywd(year: i32, week: u32, weekday: Weekday) -> NaiveDate[src]Makes a new NaiveDate from the ISO week date
-(year, week number and day of the week).
-The resulting NaiveDate may have a different year from the input year.
Panics on the out-of-range date and/or invalid week number.
--use chrono::{NaiveDate, Datelike, Weekday}; - -let d = NaiveDate::from_isoywd(2015, 11, Weekday::Sat); -assert_eq!(d.iso_week().year(), 2015); -assert_eq!(d.iso_week().week(), 11); -assert_eq!(d.weekday(), Weekday::Sat); -assert_eq!(d.year(), 2015); -assert_eq!(d.month(), 3); -assert_eq!(d.day(), 14); -assert_eq!(d.ordinal(), 73); // day of year -assert_eq!(d.num_days_from_ce(), 735671); // days since January 1, 1 CE
pub fn from_isoywd_opt(
year: i32,
week: u32,
weekday: Weekday
) -> Option<NaiveDate>[src]Makes a new NaiveDate from the ISO week date
-(year, week number and day of the week).
-The resulting NaiveDate may have a different year from the input year.
Returns None on the out-of-range date and/or invalid week number.
-use chrono::{NaiveDate, Weekday}; - -let from_ymd = NaiveDate::from_ymd; -let from_isoywd_opt = NaiveDate::from_isoywd_opt; - -assert_eq!(from_isoywd_opt(2015, 0, Weekday::Sun), None); -assert_eq!(from_isoywd_opt(2015, 10, Weekday::Sun), Some(from_ymd(2015, 3, 8))); -assert_eq!(from_isoywd_opt(2015, 30, Weekday::Mon), Some(from_ymd(2015, 7, 20))); -assert_eq!(from_isoywd_opt(2015, 60, Weekday::Mon), None); - -assert_eq!(from_isoywd_opt(400000, 10, Weekday::Fri), None); -assert_eq!(from_isoywd_opt(-400000, 10, Weekday::Sat), None);
The year number of ISO week date may differ from that of the calendar date.
- --// Mo Tu We Th Fr Sa Su -// 2014-W52 22 23 24 25 26 27 28 has 4+ days of new year, -// 2015-W01 29 30 31 1 2 3 4 <- so this is the first week -assert_eq!(from_isoywd_opt(2014, 52, Weekday::Sun), Some(from_ymd(2014, 12, 28))); -assert_eq!(from_isoywd_opt(2014, 53, Weekday::Mon), None); -assert_eq!(from_isoywd_opt(2015, 1, Weekday::Mon), Some(from_ymd(2014, 12, 29))); - -// 2015-W52 21 22 23 24 25 26 27 has 4+ days of old year, -// 2015-W53 28 29 30 31 1 2 3 <- so this is the last week -// 2016-W01 4 5 6 7 8 9 10 -assert_eq!(from_isoywd_opt(2015, 52, Weekday::Sun), Some(from_ymd(2015, 12, 27))); -assert_eq!(from_isoywd_opt(2015, 53, Weekday::Sun), Some(from_ymd(2016, 1, 3))); -assert_eq!(from_isoywd_opt(2015, 54, Weekday::Mon), None); -assert_eq!(from_isoywd_opt(2016, 1, Weekday::Mon), Some(from_ymd(2016, 1, 4)));
pub fn from_num_days_from_ce(days: i32) -> NaiveDate[src]Makes a new NaiveDate from a day's number in the proleptic Gregorian calendar, with
-January 1, 1 being day 1.
Panics if the date is out of range.
--use chrono::{NaiveDate, Datelike, Weekday}; - -let d = NaiveDate::from_num_days_from_ce(735671); -assert_eq!(d.num_days_from_ce(), 735671); // days since January 1, 1 CE -assert_eq!(d.year(), 2015); -assert_eq!(d.month(), 3); -assert_eq!(d.day(), 14); -assert_eq!(d.ordinal(), 73); // day of year -assert_eq!(d.iso_week().year(), 2015); -assert_eq!(d.iso_week().week(), 11); -assert_eq!(d.weekday(), Weekday::Sat);
While not directly supported by Chrono,
-it is easy to convert from the Julian day number
-(January 1, 4713 BCE in the Julian calendar being Day 0)
-to Gregorian with this method.
-(Note that this panics when jd is out of range.)
-use chrono::NaiveDate; - -fn jd_to_date(jd: i32) -> NaiveDate { - // keep in mind that the Julian day number is 0-based - // while this method requires an 1-based number. - NaiveDate::from_num_days_from_ce(jd - 1721425) -} - -// January 1, 4713 BCE in Julian = November 24, 4714 BCE in Gregorian -assert_eq!(jd_to_date(0), NaiveDate::from_ymd(-4713, 11, 24)); - -assert_eq!(jd_to_date(1721426), NaiveDate::from_ymd(1, 1, 1)); -assert_eq!(jd_to_date(2450000), NaiveDate::from_ymd(1995, 10, 9)); -assert_eq!(jd_to_date(2451545), NaiveDate::from_ymd(2000, 1, 1));
pub fn from_num_days_from_ce_opt(days: i32) -> Option<NaiveDate>[src]Makes a new NaiveDate from a day's number in the proleptic Gregorian calendar, with
-January 1, 1 being day 1.
Returns None if the date is out of range.
-use chrono::NaiveDate; - -let from_ndays_opt = NaiveDate::from_num_days_from_ce_opt; -let from_ymd = NaiveDate::from_ymd; - -assert_eq!(from_ndays_opt(730_000), Some(from_ymd(1999, 9, 3))); -assert_eq!(from_ndays_opt(1), Some(from_ymd(1, 1, 1))); -assert_eq!(from_ndays_opt(0), Some(from_ymd(0, 12, 31))); -assert_eq!(from_ndays_opt(-1), Some(from_ymd(0, 12, 30))); -assert_eq!(from_ndays_opt(100_000_000), None); -assert_eq!(from_ndays_opt(-100_000_000), None);
pub fn from_weekday_of_month(
year: i32,
month: u32,
weekday: Weekday,
n: u8
) -> NaiveDate[src]Makes a new NaiveDate by counting the number of occurrences of a particular day-of-week
-since the beginning of the given month. For instance, if you want the 2nd Friday of March
-2017, you would use NaiveDate::from_weekday_of_month(2017, 3, Weekday::Fri, 2).
The resulting NaiveDate is guaranteed to be in month. If n is larger than the number
-of weekday in month (eg. the 6th Friday of March 2017) then this function will panic.
n is 1-indexed. Passing n=0 will cause a panic.
-use chrono::{NaiveDate, Weekday}; - -let from_weekday_of_month = NaiveDate::from_weekday_of_month; -let from_ymd = NaiveDate::from_ymd; - -assert_eq!(from_weekday_of_month(2018, 8, Weekday::Wed, 1), from_ymd(2018, 8, 1)); -assert_eq!(from_weekday_of_month(2018, 8, Weekday::Fri, 1), from_ymd(2018, 8, 3)); -assert_eq!(from_weekday_of_month(2018, 8, Weekday::Tue, 2), from_ymd(2018, 8, 14)); -assert_eq!(from_weekday_of_month(2018, 8, Weekday::Fri, 4), from_ymd(2018, 8, 24)); -assert_eq!(from_weekday_of_month(2018, 8, Weekday::Fri, 5), from_ymd(2018, 8, 31));
pub fn from_weekday_of_month_opt(
year: i32,
month: u32,
weekday: Weekday,
n: u8
) -> Option<NaiveDate>[src]Makes a new NaiveDate by counting the number of occurrences of a particular day-of-week
-since the beginning of the given month. For instance, if you want the 2nd Friday of March
-2017, you would use NaiveDate::from_weekday_of_month(2017, 3, Weekday::Fri, 2). n is 1-indexed.
-use chrono::{NaiveDate, Weekday}; -assert_eq!(NaiveDate::from_weekday_of_month_opt(2017, 3, Weekday::Fri, 2), - NaiveDate::from_ymd_opt(2017, 3, 10))
Returns None if n out-of-range; ie. if n is larger than the number of weekday in
-month (eg. the 6th Friday of March 2017), or if n == 0.
pub fn parse_from_str(s: &str, fmt: &str) -> ParseResult<NaiveDate>[src]Parses a string with the specified format string and returns a new NaiveDate.
-See the format::strftime module
-on the supported escape sequences.
-use chrono::NaiveDate; - -let parse_from_str = NaiveDate::parse_from_str; - -assert_eq!(parse_from_str("2015-09-05", "%Y-%m-%d"), - Ok(NaiveDate::from_ymd(2015, 9, 5))); -assert_eq!(parse_from_str("5sep2015", "%d%b%Y"), - Ok(NaiveDate::from_ymd(2015, 9, 5)));
Time and offset is ignored for the purpose of parsing.
- --assert_eq!(parse_from_str("2014-5-17T12:34:56+09:30", "%Y-%m-%dT%H:%M:%S%z"), - Ok(NaiveDate::from_ymd(2014, 5, 17)));
Out-of-bound dates or insufficient fields are errors.
- --assert!(parse_from_str("2015/9", "%Y/%m").is_err()); -assert!(parse_from_str("2015/9/31", "%Y/%m/%d").is_err());
All parsed fields should be consistent to each other, otherwise it's an error.
- --assert!(parse_from_str("Sat, 09 Aug 2013", "%a, %d %b %Y").is_err());
pub fn and_time(&self, time: NaiveTime) -> NaiveDateTime[src]Makes a new NaiveDateTime from the current date and given NaiveTime.
-use chrono::{NaiveDate, NaiveTime, NaiveDateTime}; - -let d = NaiveDate::from_ymd(2015, 6, 3); -let t = NaiveTime::from_hms_milli(12, 34, 56, 789); - -let dt: NaiveDateTime = d.and_time(t); -assert_eq!(dt.date(), d); -assert_eq!(dt.time(), t);
pub fn and_hms(&self, hour: u32, min: u32, sec: u32) -> NaiveDateTime[src]Makes a new NaiveDateTime from the current date, hour, minute and second.
No leap second is allowed here;
-use NaiveDate::and_hms_* methods with a subsecond parameter instead.
Panics on invalid hour, minute and/or second.
--use chrono::{NaiveDate, NaiveDateTime, Datelike, Timelike, Weekday}; - -let d = NaiveDate::from_ymd(2015, 6, 3); - -let dt: NaiveDateTime = d.and_hms(12, 34, 56); -assert_eq!(dt.year(), 2015); -assert_eq!(dt.weekday(), Weekday::Wed); -assert_eq!(dt.second(), 56);
pub fn and_hms_opt(
&self,
hour: u32,
min: u32,
sec: u32
) -> Option<NaiveDateTime>[src]Makes a new NaiveDateTime from the current date, hour, minute and second.
No leap second is allowed here;
-use NaiveDate::and_hms_*_opt methods with a subsecond parameter instead.
Returns None on invalid hour, minute and/or second.
-use chrono::NaiveDate; - -let d = NaiveDate::from_ymd(2015, 6, 3); -assert!(d.and_hms_opt(12, 34, 56).is_some()); -assert!(d.and_hms_opt(12, 34, 60).is_none()); // use `and_hms_milli_opt` instead -assert!(d.and_hms_opt(12, 60, 56).is_none()); -assert!(d.and_hms_opt(24, 34, 56).is_none());
pub fn and_hms_milli(
&self,
hour: u32,
min: u32,
sec: u32,
milli: u32
) -> NaiveDateTime[src]Makes a new NaiveDateTime from the current date, hour, minute, second and millisecond.
The millisecond part can exceed 1,000 -in order to represent the leap second.
-Panics on invalid hour, minute, second and/or millisecond.
--use chrono::{NaiveDate, NaiveDateTime, Datelike, Timelike, Weekday}; - -let d = NaiveDate::from_ymd(2015, 6, 3); - -let dt: NaiveDateTime = d.and_hms_milli(12, 34, 56, 789); -assert_eq!(dt.year(), 2015); -assert_eq!(dt.weekday(), Weekday::Wed); -assert_eq!(dt.second(), 56); -assert_eq!(dt.nanosecond(), 789_000_000);
pub fn and_hms_milli_opt(
&self,
hour: u32,
min: u32,
sec: u32,
milli: u32
) -> Option<NaiveDateTime>[src]Makes a new NaiveDateTime from the current date, hour, minute, second and millisecond.
The millisecond part can exceed 1,000 -in order to represent the leap second.
-Returns None on invalid hour, minute, second and/or millisecond.
-use chrono::NaiveDate; - -let d = NaiveDate::from_ymd(2015, 6, 3); -assert!(d.and_hms_milli_opt(12, 34, 56, 789).is_some()); -assert!(d.and_hms_milli_opt(12, 34, 59, 1_789).is_some()); // leap second -assert!(d.and_hms_milli_opt(12, 34, 59, 2_789).is_none()); -assert!(d.and_hms_milli_opt(12, 34, 60, 789).is_none()); -assert!(d.and_hms_milli_opt(12, 60, 56, 789).is_none()); -assert!(d.and_hms_milli_opt(24, 34, 56, 789).is_none());
pub fn and_hms_micro(
&self,
hour: u32,
min: u32,
sec: u32,
micro: u32
) -> NaiveDateTime[src]Makes a new NaiveDateTime from the current date, hour, minute, second and microsecond.
The microsecond part can exceed 1,000,000 -in order to represent the leap second.
-Panics on invalid hour, minute, second and/or microsecond.
--use chrono::{NaiveDate, NaiveDateTime, Datelike, Timelike, Weekday}; - -let d = NaiveDate::from_ymd(2015, 6, 3); - -let dt: NaiveDateTime = d.and_hms_micro(12, 34, 56, 789_012); -assert_eq!(dt.year(), 2015); -assert_eq!(dt.weekday(), Weekday::Wed); -assert_eq!(dt.second(), 56); -assert_eq!(dt.nanosecond(), 789_012_000);
pub fn and_hms_micro_opt(
&self,
hour: u32,
min: u32,
sec: u32,
micro: u32
) -> Option<NaiveDateTime>[src]Makes a new NaiveDateTime from the current date, hour, minute, second and microsecond.
The microsecond part can exceed 1,000,000 -in order to represent the leap second.
-Returns None on invalid hour, minute, second and/or microsecond.
-use chrono::NaiveDate; - -let d = NaiveDate::from_ymd(2015, 6, 3); -assert!(d.and_hms_micro_opt(12, 34, 56, 789_012).is_some()); -assert!(d.and_hms_micro_opt(12, 34, 59, 1_789_012).is_some()); // leap second -assert!(d.and_hms_micro_opt(12, 34, 59, 2_789_012).is_none()); -assert!(d.and_hms_micro_opt(12, 34, 60, 789_012).is_none()); -assert!(d.and_hms_micro_opt(12, 60, 56, 789_012).is_none()); -assert!(d.and_hms_micro_opt(24, 34, 56, 789_012).is_none());
pub fn and_hms_nano(
&self,
hour: u32,
min: u32,
sec: u32,
nano: u32
) -> NaiveDateTime[src]Makes a new NaiveDateTime from the current date, hour, minute, second and nanosecond.
The nanosecond part can exceed 1,000,000,000 -in order to represent the leap second.
-Panics on invalid hour, minute, second and/or nanosecond.
--use chrono::{NaiveDate, NaiveDateTime, Datelike, Timelike, Weekday}; - -let d = NaiveDate::from_ymd(2015, 6, 3); - -let dt: NaiveDateTime = d.and_hms_nano(12, 34, 56, 789_012_345); -assert_eq!(dt.year(), 2015); -assert_eq!(dt.weekday(), Weekday::Wed); -assert_eq!(dt.second(), 56); -assert_eq!(dt.nanosecond(), 789_012_345);
pub fn and_hms_nano_opt(
&self,
hour: u32,
min: u32,
sec: u32,
nano: u32
) -> Option<NaiveDateTime>[src]Makes a new NaiveDateTime from the current date, hour, minute, second and nanosecond.
The nanosecond part can exceed 1,000,000,000 -in order to represent the leap second.
-Returns None on invalid hour, minute, second and/or nanosecond.
-use chrono::NaiveDate; - -let d = NaiveDate::from_ymd(2015, 6, 3); -assert!(d.and_hms_nano_opt(12, 34, 56, 789_012_345).is_some()); -assert!(d.and_hms_nano_opt(12, 34, 59, 1_789_012_345).is_some()); // leap second -assert!(d.and_hms_nano_opt(12, 34, 59, 2_789_012_345).is_none()); -assert!(d.and_hms_nano_opt(12, 34, 60, 789_012_345).is_none()); -assert!(d.and_hms_nano_opt(12, 60, 56, 789_012_345).is_none()); -assert!(d.and_hms_nano_opt(24, 34, 56, 789_012_345).is_none());
pub fn succ(&self) -> NaiveDate[src]Makes a new NaiveDate for the next calendar date.
Panics when self is the last representable date.
-use chrono::NaiveDate; - -assert_eq!(NaiveDate::from_ymd(2015, 6, 3).succ(), NaiveDate::from_ymd(2015, 6, 4)); -assert_eq!(NaiveDate::from_ymd(2015, 6, 30).succ(), NaiveDate::from_ymd(2015, 7, 1)); -assert_eq!(NaiveDate::from_ymd(2015, 12, 31).succ(), NaiveDate::from_ymd(2016, 1, 1));
pub fn succ_opt(&self) -> Option<NaiveDate>[src]Makes a new NaiveDate for the next calendar date.
Returns None when self is the last representable date.
-use chrono::NaiveDate; -use chrono::naive::MAX_DATE; - -assert_eq!(NaiveDate::from_ymd(2015, 6, 3).succ_opt(), - Some(NaiveDate::from_ymd(2015, 6, 4))); -assert_eq!(MAX_DATE.succ_opt(), None);
pub fn pred(&self) -> NaiveDate[src]Makes a new NaiveDate for the previous calendar date.
Panics when self is the first representable date.
-use chrono::NaiveDate; - -assert_eq!(NaiveDate::from_ymd(2015, 6, 3).pred(), NaiveDate::from_ymd(2015, 6, 2)); -assert_eq!(NaiveDate::from_ymd(2015, 6, 1).pred(), NaiveDate::from_ymd(2015, 5, 31)); -assert_eq!(NaiveDate::from_ymd(2015, 1, 1).pred(), NaiveDate::from_ymd(2014, 12, 31));
pub fn pred_opt(&self) -> Option<NaiveDate>[src]Makes a new NaiveDate for the previous calendar date.
Returns None when self is the first representable date.
-use chrono::NaiveDate; -use chrono::naive::MIN_DATE; - -assert_eq!(NaiveDate::from_ymd(2015, 6, 3).pred_opt(), - Some(NaiveDate::from_ymd(2015, 6, 2))); -assert_eq!(MIN_DATE.pred_opt(), None);
pub fn checked_add_signed(self, rhs: OldDuration) -> Option<NaiveDate>[src]Adds the days part of given Duration to the current date.
Returns None when it will result in overflow.
-use chrono::{Duration, NaiveDate}; -use chrono::naive::MAX_DATE; - -let d = NaiveDate::from_ymd(2015, 9, 5); -assert_eq!(d.checked_add_signed(Duration::days(40)), - Some(NaiveDate::from_ymd(2015, 10, 15))); -assert_eq!(d.checked_add_signed(Duration::days(-40)), - Some(NaiveDate::from_ymd(2015, 7, 27))); -assert_eq!(d.checked_add_signed(Duration::days(1_000_000_000)), None); -assert_eq!(d.checked_add_signed(Duration::days(-1_000_000_000)), None); -assert_eq!(MAX_DATE.checked_add_signed(Duration::days(1)), None);
pub fn checked_sub_signed(self, rhs: OldDuration) -> Option<NaiveDate>[src]Subtracts the days part of given Duration from the current date.
Returns None when it will result in overflow.
-use chrono::{Duration, NaiveDate}; -use chrono::naive::MIN_DATE; - -let d = NaiveDate::from_ymd(2015, 9, 5); -assert_eq!(d.checked_sub_signed(Duration::days(40)), - Some(NaiveDate::from_ymd(2015, 7, 27))); -assert_eq!(d.checked_sub_signed(Duration::days(-40)), - Some(NaiveDate::from_ymd(2015, 10, 15))); -assert_eq!(d.checked_sub_signed(Duration::days(1_000_000_000)), None); -assert_eq!(d.checked_sub_signed(Duration::days(-1_000_000_000)), None); -assert_eq!(MIN_DATE.checked_sub_signed(Duration::days(1)), None);
pub fn signed_duration_since(self, rhs: NaiveDate) -> OldDuration[src]Subtracts another NaiveDate from the current date.
-Returns a Duration of integral numbers.
This does not overflow or underflow at all,
-as all possible output fits in the range of Duration.
-use chrono::{Duration, NaiveDate}; - -let from_ymd = NaiveDate::from_ymd; -let since = NaiveDate::signed_duration_since; - -assert_eq!(since(from_ymd(2014, 1, 1), from_ymd(2014, 1, 1)), Duration::zero()); -assert_eq!(since(from_ymd(2014, 1, 1), from_ymd(2013, 12, 31)), Duration::days(1)); -assert_eq!(since(from_ymd(2014, 1, 1), from_ymd(2014, 1, 2)), Duration::days(-1)); -assert_eq!(since(from_ymd(2014, 1, 1), from_ymd(2013, 9, 23)), Duration::days(100)); -assert_eq!(since(from_ymd(2014, 1, 1), from_ymd(2013, 1, 1)), Duration::days(365)); -assert_eq!(since(from_ymd(2014, 1, 1), from_ymd(2010, 1, 1)), Duration::days(365*4 + 1)); -assert_eq!(since(from_ymd(2014, 1, 1), from_ymd(1614, 1, 1)), Duration::days(365*400 + 97));
pub fn format_with_items<'a, I, B>(&self, items: I) -> DelayedFormat<I> where
I: Iterator<Item = B> + Clone,
B: Borrow<Item<'a>>, [src]Formats the date with the specified formatting items.
-Otherwise it is the same as the ordinary format method.
The Iterator of items should be Cloneable,
-since the resulting DelayedFormat value may be formatted multiple times.
-use chrono::NaiveDate; -use chrono::format::strftime::StrftimeItems; - -let fmt = StrftimeItems::new("%Y-%m-%d"); -let d = NaiveDate::from_ymd(2015, 9, 5); -assert_eq!(d.format_with_items(fmt.clone()).to_string(), "2015-09-05"); -assert_eq!(d.format("%Y-%m-%d").to_string(), "2015-09-05");
The resulting DelayedFormat can be formatted directly via the Display trait.
-assert_eq!(format!("{}", d.format_with_items(fmt)), "2015-09-05");
pub fn format<'a>(&self, fmt: &'a str) -> DelayedFormat<StrftimeItems<'a>>[src]Formats the date with the specified format string.
-See the format::strftime module
-on the supported escape sequences.
This returns a DelayedFormat,
-which gets converted to a string only when actual formatting happens.
-You may use the to_string method to get a String,
-or just feed it into print! and other formatting macros.
-(In this way it avoids the redundant memory allocation.)
A wrong format string does not issue an error immediately.
-Rather, converting or formatting the DelayedFormat fails.
-You are recommended to immediately use DelayedFormat for this reason.
-use chrono::NaiveDate; - -let d = NaiveDate::from_ymd(2015, 9, 5); -assert_eq!(d.format("%Y-%m-%d").to_string(), "2015-09-05"); -assert_eq!(d.format("%A, %-d %B, %C%y").to_string(), "Saturday, 5 September, 2015");
The resulting DelayedFormat can be formatted directly via the Display trait.
-assert_eq!(format!("{}", d.format("%Y-%m-%d")), "2015-09-05"); -assert_eq!(format!("{}", d.format("%A, %-d %B, %C%y")), "Saturday, 5 September, 2015");
pub fn iter_days(&self) -> NaiveDateDaysIterator[src]Returns an iterator that steps by days until the last representable date.
-- -let expected = [ - NaiveDate::from_ymd(2016, 2, 27), - NaiveDate::from_ymd(2016, 2, 28), - NaiveDate::from_ymd(2016, 2, 29), - NaiveDate::from_ymd(2016, 3, 1), -]; - -let mut count = 0; -for (idx, d) in NaiveDate::from_ymd(2016, 2, 27).iter_days().take(4).enumerate() { - assert_eq!(d, expected[idx]); - count += 1; -} -assert_eq!(count, 4);
pub fn iter_weeks(&self) -> NaiveDateWeeksIterator[src]Returns an iterator that steps by weeks until the last representable date.
-- -let expected = [ - NaiveDate::from_ymd(2016, 2, 27), - NaiveDate::from_ymd(2016, 3, 5), - NaiveDate::from_ymd(2016, 3, 12), - NaiveDate::from_ymd(2016, 3, 19), -]; - -let mut count = 0; -for (idx, d) in NaiveDate::from_ymd(2016, 2, 27).iter_weeks().take(4).enumerate() { - assert_eq!(d, expected[idx]); - count += 1; -} -assert_eq!(count, 4);
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.
-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));
type Output = NaiveDateThe resulting type after applying the + operator.
fn add(self, rhs: OldDuration) -> NaiveDate[src]impl AddAssign<Duration> for NaiveDate[src]fn add_assign(&mut self, rhs: OldDuration)[src]impl Clone for NaiveDate[src]impl Copy for NaiveDate[src]impl Datelike for NaiveDate[src]fn year(&self) -> i32[src]Returns the year number in the calendar date.
--use chrono::{NaiveDate, Datelike}; - -assert_eq!(NaiveDate::from_ymd(2015, 9, 8).year(), 2015); -assert_eq!(NaiveDate::from_ymd(-308, 3, 14).year(), -308); // 309 BCE
fn month(&self) -> u32[src]Returns the month number starting from 1.
-The return value ranges from 1 to 12.
--use chrono::{NaiveDate, Datelike}; - -assert_eq!(NaiveDate::from_ymd(2015, 9, 8).month(), 9); -assert_eq!(NaiveDate::from_ymd(-308, 3, 14).month(), 3);
fn month0(&self) -> u32[src]Returns the month number starting from 0.
-The return value ranges from 0 to 11.
--use chrono::{NaiveDate, Datelike}; - -assert_eq!(NaiveDate::from_ymd(2015, 9, 8).month0(), 8); -assert_eq!(NaiveDate::from_ymd(-308, 3, 14).month0(), 2);
fn day(&self) -> u32[src]Returns the day of month starting from 1.
-The return value ranges from 1 to 31. (The last day of month differs by months.)
--use chrono::{NaiveDate, Datelike}; - -assert_eq!(NaiveDate::from_ymd(2015, 9, 8).day(), 8); -assert_eq!(NaiveDate::from_ymd(-308, 3, 14).day(), 14);
Combined with NaiveDate::pred,
-one can determine the number of days in a particular month.
-(Note that this panics when year is out of range.)
-use chrono::{NaiveDate, Datelike}; - -fn ndays_in_month(year: i32, month: u32) -> u32 { - // the first day of the next month... - let (y, m) = if month == 12 { (year + 1, 1) } else { (year, month + 1) }; - let d = NaiveDate::from_ymd(y, m, 1); - - // ...is preceded by the last day of the original month - d.pred().day() -} - -assert_eq!(ndays_in_month(2015, 8), 31); -assert_eq!(ndays_in_month(2015, 9), 30); -assert_eq!(ndays_in_month(2015, 12), 31); -assert_eq!(ndays_in_month(2016, 2), 29); -assert_eq!(ndays_in_month(2017, 2), 28);
fn day0(&self) -> u32[src]Returns the day of month starting from 0.
-The return value ranges from 0 to 30. (The last day of month differs by months.)
--use chrono::{NaiveDate, Datelike}; - -assert_eq!(NaiveDate::from_ymd(2015, 9, 8).day0(), 7); -assert_eq!(NaiveDate::from_ymd(-308, 3, 14).day0(), 13);
fn ordinal(&self) -> u32[src]Returns the day of year starting from 1.
-The return value ranges from 1 to 366. (The last day of year differs by years.)
--use chrono::{NaiveDate, Datelike}; - -assert_eq!(NaiveDate::from_ymd(2015, 9, 8).ordinal(), 251); -assert_eq!(NaiveDate::from_ymd(-308, 3, 14).ordinal(), 74);
Combined with NaiveDate::pred,
-one can determine the number of days in a particular year.
-(Note that this panics when year is out of range.)
-use chrono::{NaiveDate, Datelike}; - -fn ndays_in_year(year: i32) -> u32 { - // the first day of the next year... - let d = NaiveDate::from_ymd(year + 1, 1, 1); - - // ...is preceded by the last day of the original year - d.pred().ordinal() -} - -assert_eq!(ndays_in_year(2015), 365); -assert_eq!(ndays_in_year(2016), 366); -assert_eq!(ndays_in_year(2017), 365); -assert_eq!(ndays_in_year(2000), 366); -assert_eq!(ndays_in_year(2100), 365);
fn ordinal0(&self) -> u32[src]Returns the day of year starting from 0.
-The return value ranges from 0 to 365. (The last day of year differs by years.)
--use chrono::{NaiveDate, Datelike}; - -assert_eq!(NaiveDate::from_ymd(2015, 9, 8).ordinal0(), 250); -assert_eq!(NaiveDate::from_ymd(-308, 3, 14).ordinal0(), 73);
fn weekday(&self) -> Weekday[src]Returns the day of week.
--use chrono::{NaiveDate, Datelike, Weekday}; - -assert_eq!(NaiveDate::from_ymd(2015, 9, 8).weekday(), Weekday::Tue); -assert_eq!(NaiveDate::from_ymd(-308, 3, 14).weekday(), Weekday::Fri);
fn iso_week(&self) -> IsoWeek[src]fn with_year(&self, year: i32) -> Option<NaiveDate>[src]Makes a new NaiveDate with the year number changed.
Returns None when the resulting NaiveDate would be invalid.
-use chrono::{NaiveDate, Datelike}; - -assert_eq!(NaiveDate::from_ymd(2015, 9, 8).with_year(2016), - Some(NaiveDate::from_ymd(2016, 9, 8))); -assert_eq!(NaiveDate::from_ymd(2015, 9, 8).with_year(-308), - Some(NaiveDate::from_ymd(-308, 9, 8)));
A leap day (February 29) is a good example that this method can return None.
-assert!(NaiveDate::from_ymd(2016, 2, 29).with_year(2015).is_none()); -assert!(NaiveDate::from_ymd(2016, 2, 29).with_year(2020).is_some());
fn with_month(&self, month: u32) -> Option<NaiveDate>[src]Makes a new NaiveDate with the month number (starting from 1) changed.
Returns None when the resulting NaiveDate would be invalid.
-use chrono::{NaiveDate, Datelike}; - -assert_eq!(NaiveDate::from_ymd(2015, 9, 8).with_month(10), - Some(NaiveDate::from_ymd(2015, 10, 8))); -assert_eq!(NaiveDate::from_ymd(2015, 9, 8).with_month(13), None); // no month 13 -assert_eq!(NaiveDate::from_ymd(2015, 9, 30).with_month(2), None); // no February 30
fn with_month0(&self, month0: u32) -> Option<NaiveDate>[src]Makes a new NaiveDate with the month number (starting from 0) changed.
Returns None when the resulting NaiveDate would be invalid.
-use chrono::{NaiveDate, Datelike}; - -assert_eq!(NaiveDate::from_ymd(2015, 9, 8).with_month0(9), - Some(NaiveDate::from_ymd(2015, 10, 8))); -assert_eq!(NaiveDate::from_ymd(2015, 9, 8).with_month0(12), None); // no month 13 -assert_eq!(NaiveDate::from_ymd(2015, 9, 30).with_month0(1), None); // no February 30
fn with_day(&self, day: u32) -> Option<NaiveDate>[src]Makes a new NaiveDate with the day of month (starting from 1) changed.
Returns None when the resulting NaiveDate would be invalid.
-use chrono::{NaiveDate, Datelike}; - -assert_eq!(NaiveDate::from_ymd(2015, 9, 8).with_day(30), - Some(NaiveDate::from_ymd(2015, 9, 30))); -assert_eq!(NaiveDate::from_ymd(2015, 9, 8).with_day(31), - None); // no September 31
fn with_day0(&self, day0: u32) -> Option<NaiveDate>[src]Makes a new NaiveDate with the day of month (starting from 0) changed.
Returns None when the resulting NaiveDate would be invalid.
-use chrono::{NaiveDate, Datelike}; - -assert_eq!(NaiveDate::from_ymd(2015, 9, 8).with_day0(29), - Some(NaiveDate::from_ymd(2015, 9, 30))); -assert_eq!(NaiveDate::from_ymd(2015, 9, 8).with_day0(30), - None); // no September 31
fn with_ordinal(&self, ordinal: u32) -> Option<NaiveDate>[src]Makes a new NaiveDate with the day of year (starting from 1) changed.
Returns None when the resulting NaiveDate would be invalid.
-use chrono::{NaiveDate, Datelike}; - -assert_eq!(NaiveDate::from_ymd(2015, 1, 1).with_ordinal(60), - Some(NaiveDate::from_ymd(2015, 3, 1))); -assert_eq!(NaiveDate::from_ymd(2015, 1, 1).with_ordinal(366), - None); // 2015 had only 365 days - -assert_eq!(NaiveDate::from_ymd(2016, 1, 1).with_ordinal(60), - Some(NaiveDate::from_ymd(2016, 2, 29))); -assert_eq!(NaiveDate::from_ymd(2016, 1, 1).with_ordinal(366), - Some(NaiveDate::from_ymd(2016, 12, 31)));
fn with_ordinal0(&self, ordinal0: u32) -> Option<NaiveDate>[src]Makes a new NaiveDate with the day of year (starting from 0) changed.
Returns None when the resulting NaiveDate would be invalid.
-use chrono::{NaiveDate, Datelike}; - -assert_eq!(NaiveDate::from_ymd(2015, 1, 1).with_ordinal0(59), - Some(NaiveDate::from_ymd(2015, 3, 1))); -assert_eq!(NaiveDate::from_ymd(2015, 1, 1).with_ordinal0(365), - None); // 2015 had only 365 days - -assert_eq!(NaiveDate::from_ymd(2016, 1, 1).with_ordinal0(59), - Some(NaiveDate::from_ymd(2016, 2, 29))); -assert_eq!(NaiveDate::from_ymd(2016, 1, 1).with_ordinal0(365), - Some(NaiveDate::from_ymd(2016, 12, 31)));
fn year_ce(&self) -> (bool, u32)[src]fn num_days_from_ce(&self) -> i32[src]impl Debug for NaiveDate[src]The Debug output of the naive date d is the same as
-d.format("%Y-%m-%d").
The string printed can be readily parsed via the parse method on str.
-use chrono::NaiveDate; - -assert_eq!(format!("{:?}", NaiveDate::from_ymd(2015, 9, 5)), "2015-09-05"); -assert_eq!(format!("{:?}", NaiveDate::from_ymd( 0, 1, 1)), "0000-01-01"); -assert_eq!(format!("{:?}", NaiveDate::from_ymd(9999, 12, 31)), "9999-12-31");
ISO 8601 requires an explicit sign for years before 1 BCE or after 9999 CE.
- --assert_eq!(format!("{:?}", NaiveDate::from_ymd( -1, 1, 1)), "-0001-01-01"); -assert_eq!(format!("{:?}", NaiveDate::from_ymd(10000, 12, 31)), "+10000-12-31");
impl Display for NaiveDate[src]The Display output of the naive date d is the same as
-d.format("%Y-%m-%d").
The string printed can be readily parsed via the parse method on str.
-use chrono::NaiveDate; - -assert_eq!(format!("{}", NaiveDate::from_ymd(2015, 9, 5)), "2015-09-05"); -assert_eq!(format!("{}", NaiveDate::from_ymd( 0, 1, 1)), "0000-01-01"); -assert_eq!(format!("{}", NaiveDate::from_ymd(9999, 12, 31)), "9999-12-31");
ISO 8601 requires an explicit sign for years before 1 BCE or after 9999 CE.
- --assert_eq!(format!("{}", NaiveDate::from_ymd( -1, 1, 1)), "-0001-01-01"); -assert_eq!(format!("{}", NaiveDate::from_ymd(10000, 12, 31)), "+10000-12-31");
impl Eq for NaiveDate[src]impl FromStr for NaiveDate[src]Parsing a str into a NaiveDate uses the same format,
-%Y-%m-%d, as in Debug and Display.
-use chrono::NaiveDate; - -let d = NaiveDate::from_ymd(2015, 9, 18); -assert_eq!("2015-09-18".parse::<NaiveDate>(), Ok(d)); - -let d = NaiveDate::from_ymd(12345, 6, 7); -assert_eq!("+12345-6-7".parse::<NaiveDate>(), Ok(d)); - -assert!("foo".parse::<NaiveDate>().is_err());
type Err = ParseErrorThe associated error which can be returned from parsing.
-fn from_str(s: &str) -> ParseResult<NaiveDate>[src]impl Hash for NaiveDate[src]fn hash<__H: Hasher>(&self, state: &mut __H)[src]pub fn hash_slice<H>(data: &[Self], state: &mut H) where
H: Hasher, 1.3.0[src]impl Ord for NaiveDate[src]fn cmp(&self, other: &NaiveDate) -> Ordering[src]#[must_use]pub fn max(self, other: Self) -> Self1.21.0[src]#[must_use]pub fn min(self, other: Self) -> Self1.21.0[src]#[must_use]pub fn clamp(self, min: Self, max: Self) -> Self1.50.0[src]impl PartialEq<NaiveDate> for NaiveDate[src]impl PartialOrd<NaiveDate> for NaiveDate[src]fn partial_cmp(&self, other: &NaiveDate) -> Option<Ordering>[src]fn lt(&self, other: &NaiveDate) -> bool[src]fn le(&self, other: &NaiveDate) -> bool[src]fn gt(&self, other: &NaiveDate) -> bool[src]fn ge(&self, other: &NaiveDate) -> bool[src]impl StructuralEq for NaiveDate[src]impl StructuralPartialEq 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.
-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));
type Output = NaiveDateThe resulting type after applying the - operator.
fn sub(self, rhs: OldDuration) -> NaiveDate[src]impl Sub<NaiveDate> for NaiveDate[src]Subtracts another NaiveDate from the current date.
-Returns a Duration of integral numbers.
This does not overflow or underflow at all,
-as all possible output fits in the range of Duration.
The implementation is a wrapper around
-NaiveDate::signed_duration_since.
-use chrono::{Duration, NaiveDate}; - -let from_ymd = NaiveDate::from_ymd; - -assert_eq!(from_ymd(2014, 1, 1) - from_ymd(2014, 1, 1), Duration::zero()); -assert_eq!(from_ymd(2014, 1, 1) - from_ymd(2013, 12, 31), Duration::days(1)); -assert_eq!(from_ymd(2014, 1, 1) - from_ymd(2014, 1, 2), Duration::days(-1)); -assert_eq!(from_ymd(2014, 1, 1) - from_ymd(2013, 9, 23), Duration::days(100)); -assert_eq!(from_ymd(2014, 1, 1) - from_ymd(2013, 1, 1), Duration::days(365)); -assert_eq!(from_ymd(2014, 1, 1) - from_ymd(2010, 1, 1), Duration::days(365*4 + 1)); -assert_eq!(from_ymd(2014, 1, 1) - from_ymd(1614, 1, 1), Duration::days(365*400 + 97));
type Output = OldDurationThe resulting type after applying the - operator.
fn sub(self, rhs: NaiveDate) -> OldDuration[src]impl SubAssign<Duration> for NaiveDate[src]fn sub_assign(&mut self, rhs: OldDuration)[src]impl RefUnwindSafe for NaiveDate[src]impl Send for NaiveDate[src]impl Sync for NaiveDate[src]impl Unpin for NaiveDate[src]impl UnwindSafe for NaiveDate[src]impl<T> Any for T where
T: 'static + ?Sized, [src]impl<T> Borrow<T> for T where
T: ?Sized, [src]impl<T> BorrowMut<T> for T where
T: ?Sized, [src]pub fn borrow_mut(&mut self) -> &mut T[src]impl<T> From<T> for T[src]impl<T, U> Into<U> for T where
U: From<T>, [src]impl<T> ToOwned for T where
T: Clone, [src]type Owned = TThe resulting type after obtaining ownership.
-pub fn to_owned(&self) -> T[src]pub fn clone_into(&self, target: &mut T)[src]impl<T> ToString for T where
T: Display + ?Sized, [src]impl<T, U> TryFrom<U> for T where
U: Into<T>, [src]type Error = InfallibleThe type returned in the event of a conversion error.
-pub fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]impl<T, U> TryInto<U> for T where
U: TryFrom<T>, [src]ISO 8601 combined date and time without timezone.
-NaiveDateTime is commonly created from NaiveDate.
-use chrono::{NaiveDate, NaiveDateTime}; - -let dt: NaiveDateTime = NaiveDate::from_ymd(2016, 7, 8).and_hms(9, 10, 11);
You can use typical date-like and -time-like methods, -provided that relevant traits are in the scope.
- --use chrono::{Datelike, Timelike, Weekday}; - -assert_eq!(dt.weekday(), Weekday::Fri); -assert_eq!(dt.num_seconds_from_midnight(), 33011);
impl NaiveDateTime[src]pub fn new(date: NaiveDate, time: NaiveTime) -> NaiveDateTime[src]Makes a new NaiveDateTime from date and time components.
-Equivalent to date.and_time(time)
-and many other helper constructors on NaiveDate.
-use chrono::{NaiveDate, NaiveTime, NaiveDateTime}; - -let d = NaiveDate::from_ymd(2015, 6, 3); -let t = NaiveTime::from_hms_milli(12, 34, 56, 789); - -let dt = NaiveDateTime::new(d, t); -assert_eq!(dt.date(), d); -assert_eq!(dt.time(), t);
pub fn from_timestamp(secs: i64, nsecs: u32) -> NaiveDateTime[src]Makes a new NaiveDateTime corresponding to a UTC date and time,
-from the number of non-leap seconds
-since the midnight UTC on January 1, 1970 (aka "UNIX timestamp")
-and the number of nanoseconds since the last whole non-leap second.
For a non-naive version of this function see
-TimeZone::timestamp.
The nanosecond part can exceed 1,000,000,000 in order to represent the -leap second. (The true "UNIX -timestamp" cannot represent a leap second unambiguously.)
-Panics on the out-of-range number of seconds and/or invalid nanosecond.
--use chrono::{NaiveDateTime, NaiveDate}; - -let dt = NaiveDateTime::from_timestamp(0, 42_000_000); -assert_eq!(dt, NaiveDate::from_ymd(1970, 1, 1).and_hms_milli(0, 0, 0, 42)); - -let dt = NaiveDateTime::from_timestamp(1_000_000_000, 0); -assert_eq!(dt, NaiveDate::from_ymd(2001, 9, 9).and_hms(1, 46, 40));
pub fn from_timestamp_opt(secs: i64, nsecs: u32) -> Option<NaiveDateTime>[src]Makes a new NaiveDateTime corresponding to a UTC date and time,
-from the number of non-leap seconds
-since the midnight UTC on January 1, 1970 (aka "UNIX timestamp")
-and the number of nanoseconds since the last whole non-leap second.
The nanosecond part can exceed 1,000,000,000 -in order to represent the leap second. -(The true "UNIX timestamp" cannot represent a leap second unambiguously.)
-Returns None on the out-of-range number of seconds and/or invalid nanosecond.
-use chrono::{NaiveDateTime, NaiveDate}; -use std::i64; - -let from_timestamp_opt = NaiveDateTime::from_timestamp_opt; - -assert!(from_timestamp_opt(0, 0).is_some()); -assert!(from_timestamp_opt(0, 999_999_999).is_some()); -assert!(from_timestamp_opt(0, 1_500_000_000).is_some()); // leap second -assert!(from_timestamp_opt(0, 2_000_000_000).is_none()); -assert!(from_timestamp_opt(i64::MAX, 0).is_none());
pub fn parse_from_str(s: &str, fmt: &str) -> ParseResult<NaiveDateTime>[src]Parses a string with the specified format string and returns a new NaiveDateTime.
-See the format::strftime module
-on the supported escape sequences.
-use chrono::{NaiveDateTime, NaiveDate}; - -let parse_from_str = NaiveDateTime::parse_from_str; - -assert_eq!(parse_from_str("2015-09-05 23:56:04", "%Y-%m-%d %H:%M:%S"), - Ok(NaiveDate::from_ymd(2015, 9, 5).and_hms(23, 56, 4))); -assert_eq!(parse_from_str("5sep2015pm012345.6789", "%d%b%Y%p%I%M%S%.f"), - Ok(NaiveDate::from_ymd(2015, 9, 5).and_hms_micro(13, 23, 45, 678_900)));
Offset is ignored for the purpose of parsing.
- --assert_eq!(parse_from_str("2014-5-17T12:34:56+09:30", "%Y-%m-%dT%H:%M:%S%z"), - Ok(NaiveDate::from_ymd(2014, 5, 17).and_hms(12, 34, 56)));
Leap seconds are correctly handled by
-treating any time of the form hh:mm:60 as a leap second.
-(This equally applies to the formatting, so the round trip is possible.)
-assert_eq!(parse_from_str("2015-07-01 08:59:60.123", "%Y-%m-%d %H:%M:%S%.f"), - Ok(NaiveDate::from_ymd(2015, 7, 1).and_hms_milli(8, 59, 59, 1_123)));
Missing seconds are assumed to be zero, -but out-of-bound times or insufficient fields are errors otherwise.
- --assert_eq!(parse_from_str("94/9/4 7:15", "%y/%m/%d %H:%M"), - Ok(NaiveDate::from_ymd(1994, 9, 4).and_hms(7, 15, 0))); - -assert!(parse_from_str("04m33s", "%Mm%Ss").is_err()); -assert!(parse_from_str("94/9/4 12", "%y/%m/%d %H").is_err()); -assert!(parse_from_str("94/9/4 17:60", "%y/%m/%d %H:%M").is_err()); -assert!(parse_from_str("94/9/4 24:00:00", "%y/%m/%d %H:%M:%S").is_err());
All parsed fields should be consistent to each other, otherwise it's an error.
- --let fmt = "%Y-%m-%d %H:%M:%S = UNIX timestamp %s"; -assert!(parse_from_str("2001-09-09 01:46:39 = UNIX timestamp 999999999", fmt).is_ok()); -assert!(parse_from_str("1970-01-01 00:00:00 = UNIX timestamp 1", fmt).is_err());
pub fn date(&self) -> NaiveDate[src]Retrieves a date component.
--use chrono::NaiveDate; - -let dt = NaiveDate::from_ymd(2016, 7, 8).and_hms(9, 10, 11); -assert_eq!(dt.date(), NaiveDate::from_ymd(2016, 7, 8));
pub fn time(&self) -> NaiveTime[src]Retrieves a time component.
--use chrono::{NaiveDate, NaiveTime}; - -let dt = NaiveDate::from_ymd(2016, 7, 8).and_hms(9, 10, 11); -assert_eq!(dt.time(), NaiveTime::from_hms(9, 10, 11));
pub fn timestamp(&self) -> i64[src]Returns the number of non-leap seconds since the midnight on January 1, 1970.
-Note that this does not account for the timezone! -The true "UNIX timestamp" would count seconds since the midnight UTC on the epoch.
--use chrono::NaiveDate; - -let dt = NaiveDate::from_ymd(1970, 1, 1).and_hms_milli(0, 0, 1, 980); -assert_eq!(dt.timestamp(), 1); - -let dt = NaiveDate::from_ymd(2001, 9, 9).and_hms(1, 46, 40); -assert_eq!(dt.timestamp(), 1_000_000_000); - -let dt = NaiveDate::from_ymd(1969, 12, 31).and_hms(23, 59, 59); -assert_eq!(dt.timestamp(), -1); - -let dt = NaiveDate::from_ymd(-1, 1, 1).and_hms(0, 0, 0); -assert_eq!(dt.timestamp(), -62198755200);
pub fn timestamp_millis(&self) -> i64[src]Returns the number of non-leap milliseconds since midnight on January 1, 1970.
-Note that this does not account for the timezone! -The true "UNIX timestamp" would count seconds since the midnight UTC on the epoch.
-Note also 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.)
--use chrono::NaiveDate; - -let dt = NaiveDate::from_ymd(1970, 1, 1).and_hms_milli(0, 0, 1, 444); -assert_eq!(dt.timestamp_millis(), 1_444); - -let dt = NaiveDate::from_ymd(2001, 9, 9).and_hms_milli(1, 46, 40, 555); -assert_eq!(dt.timestamp_millis(), 1_000_000_000_555); - -let dt = NaiveDate::from_ymd(1969, 12, 31).and_hms_milli(23, 59, 59, 100); -assert_eq!(dt.timestamp_millis(), -900);
pub fn timestamp_nanos(&self) -> i64[src]Returns the number of non-leap nanoseconds since midnight on January 1, 1970.
-Note that this does not account for the timezone! -The true "UNIX timestamp" would count seconds since the midnight UTC on the epoch.
-Note also that this does reduce the number of years that can be -represented from ~584 Billion to ~584 years. The dates that can be -represented as nanoseconds are between 1677-09-21T00:12:44.0 and -2262-04-11T23:47:16.854775804.
-(If this is a problem, please file an issue to let me know what domain -needs nanosecond precision over millennia, I'm curious.)
--use chrono::{NaiveDate, NaiveDateTime}; - -let dt = NaiveDate::from_ymd(1970, 1, 1).and_hms_nano(0, 0, 1, 444); -assert_eq!(dt.timestamp_nanos(), 1_000_000_444); - -let dt = NaiveDate::from_ymd(2001, 9, 9).and_hms_nano(1, 46, 40, 555); - -const A_BILLION: i64 = 1_000_000_000; -let nanos = dt.timestamp_nanos(); -assert_eq!(nanos, 1_000_000_000_000_000_555); -assert_eq!( - dt, - NaiveDateTime::from_timestamp(nanos / A_BILLION, (nanos % A_BILLION) as u32) -);
pub fn timestamp_subsec_millis(&self) -> u32[src]Returns the number of milliseconds since the last whole non-leap second.
-The return value ranges from 0 to 999, -or for leap seconds, to 1,999.
--use chrono::NaiveDate; - -let dt = NaiveDate::from_ymd(2016, 7, 8).and_hms_nano(9, 10, 11, 123_456_789); -assert_eq!(dt.timestamp_subsec_millis(), 123); - -let dt = NaiveDate::from_ymd(2015, 7, 1).and_hms_nano(8, 59, 59, 1_234_567_890); -assert_eq!(dt.timestamp_subsec_millis(), 1_234);
pub fn timestamp_subsec_micros(&self) -> u32[src]Returns the number of microseconds since the last whole non-leap second.
-The return value ranges from 0 to 999,999, -or for leap seconds, to 1,999,999.
--use chrono::NaiveDate; - -let dt = NaiveDate::from_ymd(2016, 7, 8).and_hms_nano(9, 10, 11, 123_456_789); -assert_eq!(dt.timestamp_subsec_micros(), 123_456); - -let dt = NaiveDate::from_ymd(2015, 7, 1).and_hms_nano(8, 59, 59, 1_234_567_890); -assert_eq!(dt.timestamp_subsec_micros(), 1_234_567);
pub fn timestamp_subsec_nanos(&self) -> u32[src]Returns the number of nanoseconds since the last whole non-leap second.
-The return value ranges from 0 to 999,999,999, -or for leap seconds, to 1,999,999,999.
--use chrono::NaiveDate; - -let dt = NaiveDate::from_ymd(2016, 7, 8).and_hms_nano(9, 10, 11, 123_456_789); -assert_eq!(dt.timestamp_subsec_nanos(), 123_456_789); - -let dt = NaiveDate::from_ymd(2015, 7, 1).and_hms_nano(8, 59, 59, 1_234_567_890); -assert_eq!(dt.timestamp_subsec_nanos(), 1_234_567_890);
pub fn checked_add_signed(self, rhs: OldDuration) -> Option<NaiveDateTime>[src]Adds given Duration to the current date and time.
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.
Returns None when it will result in overflow.
-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).checked_add_signed(Duration::zero()), - Some(hms(3, 5, 7))); -assert_eq!(hms(3, 5, 7).checked_add_signed(Duration::seconds(1)), - Some(hms(3, 5, 8))); -assert_eq!(hms(3, 5, 7).checked_add_signed(Duration::seconds(-1)), - Some(hms(3, 5, 6))); -assert_eq!(hms(3, 5, 7).checked_add_signed(Duration::seconds(3600 + 60)), - Some(hms(4, 6, 7))); -assert_eq!(hms(3, 5, 7).checked_add_signed(Duration::seconds(86_400)), - Some(from_ymd(2016, 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, 980).checked_add_signed(Duration::milliseconds(450)), - Some(hmsm(3, 5, 8, 430)));
Overflow returns None.
-assert_eq!(hms(3, 5, 7).checked_add_signed(Duration::days(1_000_000_000)), None);
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.checked_add_signed(Duration::zero()), - Some(hmsm(3, 5, 59, 1_300))); -assert_eq!(leap.checked_add_signed(Duration::milliseconds(-500)), - Some(hmsm(3, 5, 59, 800))); -assert_eq!(leap.checked_add_signed(Duration::milliseconds(500)), - Some(hmsm(3, 5, 59, 1_800))); -assert_eq!(leap.checked_add_signed(Duration::milliseconds(800)), - Some(hmsm(3, 6, 0, 100))); -assert_eq!(leap.checked_add_signed(Duration::seconds(10)), - Some(hmsm(3, 6, 9, 300))); -assert_eq!(leap.checked_add_signed(Duration::seconds(-10)), - Some(hmsm(3, 5, 50, 300))); -assert_eq!(leap.checked_add_signed(Duration::days(1)), - Some(from_ymd(2016, 7, 9).and_hms_milli(3, 5, 59, 300)));
pub fn checked_sub_signed(self, rhs: OldDuration) -> Option<NaiveDateTime>[src]Subtracts given Duration from the current date and time.
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.
Returns None when it will result in overflow.
-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).checked_sub_signed(Duration::zero()), - Some(hms(3, 5, 7))); -assert_eq!(hms(3, 5, 7).checked_sub_signed(Duration::seconds(1)), - Some(hms(3, 5, 6))); -assert_eq!(hms(3, 5, 7).checked_sub_signed(Duration::seconds(-1)), - Some(hms(3, 5, 8))); -assert_eq!(hms(3, 5, 7).checked_sub_signed(Duration::seconds(3600 + 60)), - Some(hms(2, 4, 7))); -assert_eq!(hms(3, 5, 7).checked_sub_signed(Duration::seconds(86_400)), - Some(from_ymd(2016, 7, 7).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).checked_sub_signed(Duration::milliseconds(670)), - Some(hmsm(3, 5, 6, 780)));
Overflow returns None.
-assert_eq!(hms(3, 5, 7).checked_sub_signed(Duration::days(1_000_000_000)), None);
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.checked_sub_signed(Duration::zero()), - Some(hmsm(3, 5, 59, 1_300))); -assert_eq!(leap.checked_sub_signed(Duration::milliseconds(200)), - Some(hmsm(3, 5, 59, 1_100))); -assert_eq!(leap.checked_sub_signed(Duration::milliseconds(500)), - Some(hmsm(3, 5, 59, 800))); -assert_eq!(leap.checked_sub_signed(Duration::seconds(60)), - Some(hmsm(3, 5, 0, 300))); -assert_eq!(leap.checked_sub_signed(Duration::days(1)), - Some(from_ymd(2016, 7, 7).and_hms_milli(3, 6, 0, 300)));
pub fn signed_duration_since(self, rhs: NaiveDateTime) -> OldDuration[src]Subtracts another NaiveDateTime from the current date and time.
-This does not overflow or underflow at all.
As a part of Chrono's leap second handling,
-the subtraction assumes that there is no leap second ever,
-except when any of the NaiveDateTimes themselves represents a leap second
-in which case the assumption becomes that
-there are exactly one (or two) leap second(s) ever.
-use chrono::{Duration, NaiveDate}; - -let from_ymd = NaiveDate::from_ymd; - -let d = from_ymd(2016, 7, 8); -assert_eq!(d.and_hms(3, 5, 7).signed_duration_since(d.and_hms(2, 4, 6)), - Duration::seconds(3600 + 60 + 1)); - -// July 8 is 190th day in the year 2016 -let d0 = from_ymd(2016, 1, 1); -assert_eq!(d.and_hms_milli(0, 7, 6, 500).signed_duration_since(d0.and_hms(0, 0, 0)), - Duration::seconds(189 * 86_400 + 7 * 60 + 6) + Duration::milliseconds(500));
Leap seconds are handled, but the subtraction assumes that -there were no other leap seconds happened.
- --let leap = from_ymd(2015, 6, 30).and_hms_milli(23, 59, 59, 1_500); -assert_eq!(leap.signed_duration_since(from_ymd(2015, 6, 30).and_hms(23, 0, 0)), - Duration::seconds(3600) + Duration::milliseconds(500)); -assert_eq!(from_ymd(2015, 7, 1).and_hms(1, 0, 0).signed_duration_since(leap), - Duration::seconds(3600) - Duration::milliseconds(500));
pub fn format_with_items<'a, I, B>(&self, items: I) -> DelayedFormat<I> where
I: Iterator<Item = B> + Clone,
B: Borrow<Item<'a>>, [src]Formats the combined date and time with the specified formatting items.
-Otherwise it is the same as the ordinary format method.
The Iterator of items should be Cloneable,
-since the resulting DelayedFormat value may be formatted multiple times.
-use chrono::NaiveDate; -use chrono::format::strftime::StrftimeItems; - -let fmt = StrftimeItems::new("%Y-%m-%d %H:%M:%S"); -let dt = NaiveDate::from_ymd(2015, 9, 5).and_hms(23, 56, 4); -assert_eq!(dt.format_with_items(fmt.clone()).to_string(), "2015-09-05 23:56:04"); -assert_eq!(dt.format("%Y-%m-%d %H:%M:%S").to_string(), "2015-09-05 23:56:04");
The resulting DelayedFormat can be formatted directly via the Display trait.
-assert_eq!(format!("{}", dt.format_with_items(fmt)), "2015-09-05 23:56:04");
pub fn format<'a>(&self, fmt: &'a str) -> DelayedFormat<StrftimeItems<'a>>[src]Formats the combined date and time with the specified format string.
-See the format::strftime module
-on the supported escape sequences.
This returns a DelayedFormat,
-which gets converted to a string only when actual formatting happens.
-You may use the to_string method to get a String,
-or just feed it into print! and other formatting macros.
-(In this way it avoids the redundant memory allocation.)
A wrong format string does not issue an error immediately.
-Rather, converting or formatting the DelayedFormat fails.
-You are recommended to immediately use DelayedFormat for this reason.
-use chrono::NaiveDate; - -let dt = NaiveDate::from_ymd(2015, 9, 5).and_hms(23, 56, 4); -assert_eq!(dt.format("%Y-%m-%d %H:%M:%S").to_string(), "2015-09-05 23:56:04"); -assert_eq!(dt.format("around %l %p on %b %-d").to_string(), "around 11 PM on Sep 5");
The resulting DelayedFormat can be formatted directly via the Display trait.
-assert_eq!(format!("{}", dt.format("%Y-%m-%d %H:%M:%S")), "2015-09-05 23:56:04"); -assert_eq!(format!("{}", dt.format("around %l %p on %b %-d")), "around 11 PM on Sep 5");
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.
-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 = NaiveDateTimeThe resulting type after applying the + operator.
fn add(self, rhs: OldDuration) -> NaiveDateTime[src]impl Add<FixedOffset> for NaiveDateTime[src]type Output = NaiveDateTimeThe resulting type after applying the + operator.
fn add(self, rhs: FixedOffset) -> NaiveDateTime[src]impl AddAssign<Duration> for NaiveDateTime[src]fn add_assign(&mut self, rhs: OldDuration)[src]impl Clone for NaiveDateTime[src]fn clone(&self) -> NaiveDateTime[src]pub fn clone_from(&mut self, source: &Self)1.0.0[src]impl Copy for NaiveDateTime[src]impl Datelike for NaiveDateTime[src]fn year(&self) -> i32[src]Returns the year number in the calendar date.
-See also the NaiveDate::year method.
-use chrono::{NaiveDate, NaiveDateTime, Datelike}; - -let dt: NaiveDateTime = NaiveDate::from_ymd(2015, 9, 25).and_hms(12, 34, 56); -assert_eq!(dt.year(), 2015);
fn month(&self) -> u32[src]Returns the month number starting from 1.
-The return value ranges from 1 to 12.
-See also the NaiveDate::month method.
-use chrono::{NaiveDate, NaiveDateTime, Datelike}; - -let dt: NaiveDateTime = NaiveDate::from_ymd(2015, 9, 25).and_hms(12, 34, 56); -assert_eq!(dt.month(), 9);
fn month0(&self) -> u32[src]Returns the month number starting from 0.
-The return value ranges from 0 to 11.
-See also the NaiveDate::month0 method.
-use chrono::{NaiveDate, NaiveDateTime, Datelike}; - -let dt: NaiveDateTime = NaiveDate::from_ymd(2015, 9, 25).and_hms(12, 34, 56); -assert_eq!(dt.month0(), 8);
fn day(&self) -> u32[src]Returns the day of month starting from 1.
-The return value ranges from 1 to 31. (The last day of month differs by months.)
-See also the NaiveDate::day method.
-use chrono::{NaiveDate, NaiveDateTime, Datelike}; - -let dt: NaiveDateTime = NaiveDate::from_ymd(2015, 9, 25).and_hms(12, 34, 56); -assert_eq!(dt.day(), 25);
fn day0(&self) -> u32[src]Returns the day of month starting from 0.
-The return value ranges from 0 to 30. (The last day of month differs by months.)
-See also the NaiveDate::day0 method.
-use chrono::{NaiveDate, NaiveDateTime, Datelike}; - -let dt: NaiveDateTime = NaiveDate::from_ymd(2015, 9, 25).and_hms(12, 34, 56); -assert_eq!(dt.day0(), 24);
fn ordinal(&self) -> u32[src]Returns the day of year starting from 1.
-The return value ranges from 1 to 366. (The last day of year differs by years.)
-See also the NaiveDate::ordinal method.
-use chrono::{NaiveDate, NaiveDateTime, Datelike}; - -let dt: NaiveDateTime = NaiveDate::from_ymd(2015, 9, 25).and_hms(12, 34, 56); -assert_eq!(dt.ordinal(), 268);
fn ordinal0(&self) -> u32[src]Returns the day of year starting from 0.
-The return value ranges from 0 to 365. (The last day of year differs by years.)
-See also the NaiveDate::ordinal0 method.
-use chrono::{NaiveDate, NaiveDateTime, Datelike}; - -let dt: NaiveDateTime = NaiveDate::from_ymd(2015, 9, 25).and_hms(12, 34, 56); -assert_eq!(dt.ordinal0(), 267);
fn weekday(&self) -> Weekday[src]Returns the day of week.
-See also the NaiveDate::weekday method.
-use chrono::{NaiveDate, NaiveDateTime, Datelike, Weekday}; - -let dt: NaiveDateTime = NaiveDate::from_ymd(2015, 9, 25).and_hms(12, 34, 56); -assert_eq!(dt.weekday(), Weekday::Fri);
fn iso_week(&self) -> IsoWeek[src]fn with_year(&self, year: i32) -> Option<NaiveDateTime>[src]Makes a new NaiveDateTime with the year number changed.
Returns None when the resulting NaiveDateTime would be invalid.
See also the
-NaiveDate::with_year method.
-use chrono::{NaiveDate, NaiveDateTime, Datelike}; - -let dt: NaiveDateTime = NaiveDate::from_ymd(2015, 9, 25).and_hms(12, 34, 56); -assert_eq!(dt.with_year(2016), Some(NaiveDate::from_ymd(2016, 9, 25).and_hms(12, 34, 56))); -assert_eq!(dt.with_year(-308), Some(NaiveDate::from_ymd(-308, 9, 25).and_hms(12, 34, 56)));
fn with_month(&self, month: u32) -> Option<NaiveDateTime>[src]Makes a new NaiveDateTime with the month number (starting from 1) changed.
Returns None when the resulting NaiveDateTime would be invalid.
See also the
-NaiveDate::with_month method.
-use chrono::{NaiveDate, NaiveDateTime, Datelike}; - -let dt: NaiveDateTime = NaiveDate::from_ymd(2015, 9, 30).and_hms(12, 34, 56); -assert_eq!(dt.with_month(10), Some(NaiveDate::from_ymd(2015, 10, 30).and_hms(12, 34, 56))); -assert_eq!(dt.with_month(13), None); // no month 13 -assert_eq!(dt.with_month(2), None); // no February 30
fn with_month0(&self, month0: u32) -> Option<NaiveDateTime>[src]Makes a new NaiveDateTime with the month number (starting from 0) changed.
Returns None when the resulting NaiveDateTime would be invalid.
See also the
-NaiveDate::with_month0 method.
-use chrono::{NaiveDate, NaiveDateTime, Datelike}; - -let dt: NaiveDateTime = NaiveDate::from_ymd(2015, 9, 30).and_hms(12, 34, 56); -assert_eq!(dt.with_month0(9), Some(NaiveDate::from_ymd(2015, 10, 30).and_hms(12, 34, 56))); -assert_eq!(dt.with_month0(12), None); // no month 13 -assert_eq!(dt.with_month0(1), None); // no February 30
fn with_day(&self, day: u32) -> Option<NaiveDateTime>[src]Makes a new NaiveDateTime with the day of month (starting from 1) changed.
Returns None when the resulting NaiveDateTime would be invalid.
See also the
-NaiveDate::with_day method.
-use chrono::{NaiveDate, NaiveDateTime, Datelike}; - -let dt: NaiveDateTime = NaiveDate::from_ymd(2015, 9, 8).and_hms(12, 34, 56); -assert_eq!(dt.with_day(30), Some(NaiveDate::from_ymd(2015, 9, 30).and_hms(12, 34, 56))); -assert_eq!(dt.with_day(31), None); // no September 31
fn with_day0(&self, day0: u32) -> Option<NaiveDateTime>[src]Makes a new NaiveDateTime with the day of month (starting from 0) changed.
Returns None when the resulting NaiveDateTime would be invalid.
See also the
-NaiveDate::with_day0 method.
-use chrono::{NaiveDate, NaiveDateTime, Datelike}; - -let dt: NaiveDateTime = NaiveDate::from_ymd(2015, 9, 8).and_hms(12, 34, 56); -assert_eq!(dt.with_day0(29), Some(NaiveDate::from_ymd(2015, 9, 30).and_hms(12, 34, 56))); -assert_eq!(dt.with_day0(30), None); // no September 31
fn with_ordinal(&self, ordinal: u32) -> Option<NaiveDateTime>[src]Makes a new NaiveDateTime with the day of year (starting from 1) changed.
Returns None when the resulting NaiveDateTime would be invalid.
See also the
-NaiveDate::with_ordinal method.
-use chrono::{NaiveDate, NaiveDateTime, Datelike}; - -let dt: NaiveDateTime = NaiveDate::from_ymd(2015, 9, 8).and_hms(12, 34, 56); -assert_eq!(dt.with_ordinal(60), - Some(NaiveDate::from_ymd(2015, 3, 1).and_hms(12, 34, 56))); -assert_eq!(dt.with_ordinal(366), None); // 2015 had only 365 days - -let dt: NaiveDateTime = NaiveDate::from_ymd(2016, 9, 8).and_hms(12, 34, 56); -assert_eq!(dt.with_ordinal(60), - Some(NaiveDate::from_ymd(2016, 2, 29).and_hms(12, 34, 56))); -assert_eq!(dt.with_ordinal(366), - Some(NaiveDate::from_ymd(2016, 12, 31).and_hms(12, 34, 56)));
fn with_ordinal0(&self, ordinal0: u32) -> Option<NaiveDateTime>[src]Makes a new NaiveDateTime with the day of year (starting from 0) changed.
Returns None when the resulting NaiveDateTime would be invalid.
See also the
-NaiveDate::with_ordinal0 method.
-use chrono::{NaiveDate, NaiveDateTime, Datelike}; - -let dt: NaiveDateTime = NaiveDate::from_ymd(2015, 9, 8).and_hms(12, 34, 56); -assert_eq!(dt.with_ordinal0(59), - Some(NaiveDate::from_ymd(2015, 3, 1).and_hms(12, 34, 56))); -assert_eq!(dt.with_ordinal0(365), None); // 2015 had only 365 days - -let dt: NaiveDateTime = NaiveDate::from_ymd(2016, 9, 8).and_hms(12, 34, 56); -assert_eq!(dt.with_ordinal0(59), - Some(NaiveDate::from_ymd(2016, 2, 29).and_hms(12, 34, 56))); -assert_eq!(dt.with_ordinal0(365), - Some(NaiveDate::from_ymd(2016, 12, 31).and_hms(12, 34, 56)));
fn year_ce(&self) -> (bool, u32)[src]fn num_days_from_ce(&self) -> i32[src]impl Debug for NaiveDateTime[src]The Debug output of the naive date and time dt is the same as
-dt.format("%Y-%m-%dT%H:%M:%S%.f").
The string printed can be readily parsed via the parse method on str.
It should be noted that, for leap seconds not on the minute boundary, -it may print a representation not distinguishable from non-leap seconds. -This doesn't matter in practice, since such leap seconds never happened. -(By the time of the first leap second on 1972-06-30, -every time zone offset around the world has standardized to the 5-minute alignment.)
--use chrono::NaiveDate; - -let dt = NaiveDate::from_ymd(2016, 11, 15).and_hms(7, 39, 24); -assert_eq!(format!("{:?}", dt), "2016-11-15T07:39:24");
Leap seconds may also be used.
- --let dt = NaiveDate::from_ymd(2015, 6, 30).and_hms_milli(23, 59, 59, 1_500); -assert_eq!(format!("{:?}", dt), "2015-06-30T23:59:60.500");
impl Display for NaiveDateTime[src]The Display output of the naive date and time dt is the same as
-dt.format("%Y-%m-%d %H:%M:%S%.f").
It should be noted that, for leap seconds not on the minute boundary, -it may print a representation not distinguishable from non-leap seconds. -This doesn't matter in practice, since such leap seconds never happened. -(By the time of the first leap second on 1972-06-30, -every time zone offset around the world has standardized to the 5-minute alignment.)
--use chrono::NaiveDate; - -let dt = NaiveDate::from_ymd(2016, 11, 15).and_hms(7, 39, 24); -assert_eq!(format!("{}", dt), "2016-11-15 07:39:24");
Leap seconds may also be used.
- --let dt = NaiveDate::from_ymd(2015, 6, 30).and_hms_milli(23, 59, 59, 1_500); -assert_eq!(format!("{}", dt), "2015-06-30 23:59:60.500");
impl Eq for NaiveDateTime[src]impl FromStr for NaiveDateTime[src]Parsing a str into a NaiveDateTime uses the same format,
-%Y-%m-%dT%H:%M:%S%.f, as in Debug.
-use chrono::{NaiveDateTime, NaiveDate}; - -let dt = NaiveDate::from_ymd(2015, 9, 18).and_hms(23, 56, 4); -assert_eq!("2015-09-18T23:56:04".parse::<NaiveDateTime>(), Ok(dt)); - -let dt = NaiveDate::from_ymd(12345, 6, 7).and_hms_milli(7, 59, 59, 1_500); // leap second -assert_eq!("+12345-6-7T7:59:60.5".parse::<NaiveDateTime>(), Ok(dt)); - -assert!("foo".parse::<NaiveDateTime>().is_err());
type Err = ParseErrorThe associated error which can be returned from parsing.
-fn from_str(s: &str) -> ParseResult<NaiveDateTime>[src]impl Hash for NaiveDateTime[src]NaiveDateTime can be used as a key to the hash maps (in principle).
Practically this also takes account of fractional seconds, so it is not recommended. -(For the obvious reason this also distinguishes leap seconds from non-leap seconds.)
-fn hash<H: Hasher>(&self, state: &mut H)[src]pub fn hash_slice<H>(data: &[Self], state: &mut H) where
H: Hasher, 1.3.0[src]impl Ord for NaiveDateTime[src]fn cmp(&self, other: &NaiveDateTime) -> Ordering[src]#[must_use]pub fn max(self, other: Self) -> Self1.21.0[src]#[must_use]pub fn min(self, other: Self) -> Self1.21.0[src]#[must_use]pub fn clamp(self, min: Self, max: Self) -> Self1.50.0[src]impl PartialEq<NaiveDateTime> for NaiveDateTime[src]fn eq(&self, other: &NaiveDateTime) -> bool[src]fn ne(&self, other: &NaiveDateTime) -> bool[src]impl PartialOrd<NaiveDateTime> for NaiveDateTime[src]fn partial_cmp(&self, other: &NaiveDateTime) -> Option<Ordering>[src]fn lt(&self, other: &NaiveDateTime) -> bool[src]fn le(&self, other: &NaiveDateTime) -> bool[src]fn gt(&self, other: &NaiveDateTime) -> bool[src]fn ge(&self, other: &NaiveDateTime) -> bool[src]impl StructuralEq for NaiveDateTime[src]impl StructuralPartialEq 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.
-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 = NaiveDateTimeThe resulting type after applying the - operator.
fn sub(self, rhs: OldDuration) -> NaiveDateTime[src]impl Sub<FixedOffset> for NaiveDateTime[src]type Output = NaiveDateTimeThe resulting type after applying the - operator.
fn sub(self, rhs: FixedOffset) -> NaiveDateTime[src]impl Sub<NaiveDateTime> for NaiveDateTime[src]Subtracts another NaiveDateTime from the current date and time.
-This does not overflow or underflow at all.
As a part of Chrono's leap second handling,
-the subtraction assumes that there is no leap second ever,
-except when any of the NaiveDateTimes themselves represents a leap second
-in which case the assumption becomes that
-there are exactly one (or two) leap second(s) ever.
The implementation is a wrapper around
-NaiveDateTime::signed_duration_since.
-use chrono::{Duration, NaiveDate}; - -let from_ymd = NaiveDate::from_ymd; - -let d = from_ymd(2016, 7, 8); -assert_eq!(d.and_hms(3, 5, 7) - d.and_hms(2, 4, 6), Duration::seconds(3600 + 60 + 1)); - -// July 8 is 190th day in the year 2016 -let d0 = from_ymd(2016, 1, 1); -assert_eq!(d.and_hms_milli(0, 7, 6, 500) - d0.and_hms(0, 0, 0), - Duration::seconds(189 * 86_400 + 7 * 60 + 6) + Duration::milliseconds(500));
Leap seconds are handled, but the subtraction assumes that -there were no other leap seconds happened.
- --let leap = from_ymd(2015, 6, 30).and_hms_milli(23, 59, 59, 1_500); -assert_eq!(leap - from_ymd(2015, 6, 30).and_hms(23, 0, 0), - Duration::seconds(3600) + Duration::milliseconds(500)); -assert_eq!(from_ymd(2015, 7, 1).and_hms(1, 0, 0) - leap, - Duration::seconds(3600) - Duration::milliseconds(500));
type Output = OldDurationThe resulting type after applying the - operator.
fn sub(self, rhs: NaiveDateTime) -> OldDuration[src]impl SubAssign<Duration> for NaiveDateTime[src]fn sub_assign(&mut self, rhs: OldDuration)[src]impl Timelike for NaiveDateTime[src]fn hour(&self) -> u32[src]Returns the hour number from 0 to 23.
-See also the NaiveTime::hour method.
-use chrono::{NaiveDate, NaiveDateTime, Timelike}; - -let dt: NaiveDateTime = NaiveDate::from_ymd(2015, 9, 8).and_hms_milli(12, 34, 56, 789); -assert_eq!(dt.hour(), 12);
fn minute(&self) -> u32[src]Returns the minute number from 0 to 59.
-See also the NaiveTime::minute method.
-use chrono::{NaiveDate, NaiveDateTime, Timelike}; - -let dt: NaiveDateTime = NaiveDate::from_ymd(2015, 9, 8).and_hms_milli(12, 34, 56, 789); -assert_eq!(dt.minute(), 34);
fn second(&self) -> u32[src]Returns the second number from 0 to 59.
-See also the NaiveTime::second method.
-use chrono::{NaiveDate, NaiveDateTime, Timelike}; - -let dt: NaiveDateTime = NaiveDate::from_ymd(2015, 9, 8).and_hms_milli(12, 34, 56, 789); -assert_eq!(dt.second(), 56);
fn nanosecond(&self) -> u32[src]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.
-See also the
-NaiveTime::nanosecond method.
-use chrono::{NaiveDate, NaiveDateTime, Timelike}; - -let dt: NaiveDateTime = NaiveDate::from_ymd(2015, 9, 8).and_hms_milli(12, 34, 56, 789); -assert_eq!(dt.nanosecond(), 789_000_000);
fn with_hour(&self, hour: u32) -> Option<NaiveDateTime>[src]Makes a new NaiveDateTime with the hour number changed.
Returns None when the resulting NaiveDateTime would be invalid.
See also the
-NaiveTime::with_hour method.
-use chrono::{NaiveDate, NaiveDateTime, Timelike}; - -let dt: NaiveDateTime = NaiveDate::from_ymd(2015, 9, 8).and_hms_milli(12, 34, 56, 789); -assert_eq!(dt.with_hour(7), - Some(NaiveDate::from_ymd(2015, 9, 8).and_hms_milli(7, 34, 56, 789))); -assert_eq!(dt.with_hour(24), None);
fn with_minute(&self, min: u32) -> Option<NaiveDateTime>[src]Makes a new NaiveDateTime with the minute number changed.
Returns None when the resulting NaiveDateTime would be invalid.
See also the
-NaiveTime::with_minute method.
-use chrono::{NaiveDate, NaiveDateTime, Timelike}; - -let dt: NaiveDateTime = NaiveDate::from_ymd(2015, 9, 8).and_hms_milli(12, 34, 56, 789); -assert_eq!(dt.with_minute(45), - Some(NaiveDate::from_ymd(2015, 9, 8).and_hms_milli(12, 45, 56, 789))); -assert_eq!(dt.with_minute(60), None);
fn with_second(&self, sec: u32) -> Option<NaiveDateTime>[src]Makes a new NaiveDateTime with the second number changed.
Returns None when the resulting NaiveDateTime would be invalid.
-As with the second method,
-the input range is restricted to 0 through 59.
See also the
-NaiveTime::with_second method.
-use chrono::{NaiveDate, NaiveDateTime, Timelike}; - -let dt: NaiveDateTime = NaiveDate::from_ymd(2015, 9, 8).and_hms_milli(12, 34, 56, 789); -assert_eq!(dt.with_second(17), - Some(NaiveDate::from_ymd(2015, 9, 8).and_hms_milli(12, 34, 17, 789))); -assert_eq!(dt.with_second(60), None);
fn with_nanosecond(&self, nano: u32) -> Option<NaiveDateTime>[src]Makes a new NaiveDateTime with nanoseconds since the whole non-leap second changed.
Returns None when the resulting NaiveDateTime would be invalid.
-As with the nanosecond method,
-the input range can exceed 1,000,000,000 for leap seconds.
See also the
-NaiveTime::with_nanosecond
-method.
-use chrono::{NaiveDate, NaiveDateTime, Timelike}; - -let dt: NaiveDateTime = NaiveDate::from_ymd(2015, 9, 8).and_hms_milli(12, 34, 56, 789); -assert_eq!(dt.with_nanosecond(333_333_333), - Some(NaiveDate::from_ymd(2015, 9, 8).and_hms_nano(12, 34, 56, 333_333_333))); -assert_eq!(dt.with_nanosecond(1_333_333_333), // leap second - Some(NaiveDate::from_ymd(2015, 9, 8).and_hms_nano(12, 34, 56, 1_333_333_333))); -assert_eq!(dt.with_nanosecond(2_000_000_000), None);
fn hour12(&self) -> (bool, u32)[src]fn num_seconds_from_midnight(&self) -> u32[src]impl RefUnwindSafe for NaiveDateTime[src]impl Send for NaiveDateTime[src]impl Sync for NaiveDateTime[src]impl Unpin for NaiveDateTime[src]impl UnwindSafe for NaiveDateTime[src]impl<T> Any for T where
T: 'static + ?Sized, [src]impl<T> Borrow<T> for T where
T: ?Sized, [src]impl<T> BorrowMut<T> for T where
T: ?Sized, [src]pub fn borrow_mut(&mut self) -> &mut T[src]impl<T> From<T> for T[src]impl<T, U> Into<U> for T where
U: From<T>, [src]impl<T> ToOwned for T where
T: Clone, [src]type Owned = TThe resulting type after obtaining ownership.
-pub fn to_owned(&self) -> T[src]pub fn clone_into(&self, target: &mut T)[src]impl<T> ToString for T where
T: Display + ?Sized, [src]impl<T, U> TryFrom<U> for T where
U: Into<T>, [src]type Error = InfallibleThe type returned in the event of a conversion error.
-pub fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]impl<T, U> TryInto<U> for T where
U: TryFrom<T>, [src]ISO 8601 time without timezone. -Allows for the nanosecond precision and optional leap second representation.
-Since 1960s, the manmade atomic clock has been so accurate that -it is much more accurate than Earth's own motion. -It became desirable to define the civil time in terms of the atomic clock, -but that risks the desynchronization of the civil time from Earth. -To account for this, the designers of the Coordinated Universal Time (UTC) -made that the UTC should be kept within 0.9 seconds of the observed Earth-bound time. -When the mean solar day is longer than the ideal (86,400 seconds), -the error slowly accumulates and it is necessary to add a leap second -to slow the UTC down a bit. -(We may also remove a second to speed the UTC up a bit, but it never happened.) -The leap second, if any, follows 23:59:59 of June 30 or December 31 in the UTC.
-Fast forward to the 21st century, -we have seen 26 leap seconds from January 1972 to December 2015. -Yes, 26 seconds. Probably you can read this paragraph within 26 seconds. -But those 26 seconds, and possibly more in the future, are never predictable, -and whether to add a leap second or not is known only before 6 months. -Internet-based clocks (via NTP) do account for known leap seconds, -but the system API normally doesn't (and often can't, with no network connection) -and there is no reliable way to retrieve leap second information.
-Chrono does not try to accurately implement leap seconds; it is impossible. -Rather, it allows for leap seconds but behaves as if there are no other leap seconds. -Various operations will ignore any possible leap second(s) -except when any of the operands were actually leap seconds.
-If you cannot tolerate this behavior,
-you must use a separate TimeZone for the International Atomic Time (TAI).
-TAI is like UTC but has no leap seconds, and thus slightly differs from UTC.
-Chrono does not yet provide such implementation, but it is planned.
The leap second is indicated via fractional seconds more than 1 second. -This makes possible to treat a leap second as the prior non-leap second -if you don't care about sub-second accuracy. -You should use the proper formatting to get the raw leap second.
-All methods accepting fractional seconds will accept such values.
- --use chrono::{NaiveDate, NaiveTime, Utc, TimeZone}; - -let t = NaiveTime::from_hms_milli(8, 59, 59, 1_000); - -let dt1 = NaiveDate::from_ymd(2015, 7, 1).and_hms_micro(8, 59, 59, 1_000_000); - -let dt2 = Utc.ymd(2015, 6, 30).and_hms_nano(23, 59, 59, 1_000_000_000);
Note that the leap second can happen anytime given an appropriate time zone; -2015-07-01 01:23:60 would be a proper leap second if UTC+01:24 had existed. -Practically speaking, though, by the time of the first leap second on 1972-06-30, -every time zone offset around the world has standardized to the 5-minute alignment.
-As a concrete example, let's assume that 03:00:60 and 04:00:60 are leap seconds.
-In reality, of course, leap seconds are separated by at least 6 months.
-We will also use some intuitive concise notations for the explanation.
Time + Duration
-(short for NaiveTime::overflowing_add_signed):
03:00:00 + 1s = 03:00:01.03:00:59 + 60s = 03:02:00.03:00:59 + 1s = 03:01:00.03:00:60 + 1s = 03:01:00.
-Note that the sum is identical to the previous.03:00:60 + 60s = 03:01:59.03:00:60 + 61s = 03:02:00.03:00:60.1 + 0.8s = 03:00:60.9.Time - Duration
-(short for NaiveTime::overflowing_sub_signed):
03:00:00 - 1s = 02:59:59.03:01:00 - 1s = 03:00:59.03:01:00 - 60s = 03:00:00.03:00:60 - 60s = 03:00:00.
-Note that the result is identical to the previous.03:00:60.7 - 0.4s = 03:00:60.3.03:00:60.7 - 0.9s = 03:00:59.8.Time - Time
-(short for NaiveTime::signed_duration_since):
04:00:00 - 03:00:00 = 3600s.03:01:00 - 03:00:00 = 60s.03:00:60 - 03:00:00 = 60s.
-Note that the difference is identical to the previous.03:00:60.6 - 03:00:59.4 = 1.2s.03:01:00 - 03:00:59.8 = 0.2s.03:01:00 - 03:00:60.5 = 0.5s.
-Note that the difference is larger than the previous,
-even though the leap second clearly follows the previous whole second.04:00:60.9 - 03:00:60.1 = (04:00:60.9 - 04:00:00) + (04:00:00 - 03:01:00) + (03:01:00 - 03:00:60.1) = 60.9s + 3540s + 0.9s = 3601.8s.In general,
-Time + Duration unconditionally equals to Duration + Time.
Time - Duration unconditionally equals to Time + (-Duration).
Time1 - Time2 unconditionally equals to -(Time2 - Time1).
Associativity does not generally hold, because
-(Time + Duration1) - Duration2 no longer equals to Time + (Duration1 - Duration2)
-for two positive durations.
As a special case, (Time + Duration) - Duration also does not equal to Time.
If you can assume that all durations have the same sign, however,
-then the associativity holds:
-(Time + Duration1) + Duration2 equals to Time + (Duration1 + Duration2)
-for two positive durations.
The "typical" leap seconds on the minute boundary are -correctly handled both in the formatting and parsing. -The leap second in the human-readable representation -will be represented as the second part being 60, as required by ISO 8601.
- --use chrono::{Utc, TimeZone}; - -let dt = Utc.ymd(2015, 6, 30).and_hms_milli(23, 59, 59, 1_000); -assert_eq!(format!("{:?}", dt), "2015-06-30T23:59:60Z");
There are hypothetical leap seconds not on the minute boundary -nevertheless supported by Chrono. -They are allowed for the sake of completeness and consistency; -there were several "exotic" time zone offsets with fractional minutes prior to UTC after all. -For such cases the human-readable representation is ambiguous -and would be read back to the next non-leap second.
- --use chrono::{DateTime, Utc, TimeZone}; - -let dt = Utc.ymd(2015, 6, 30).and_hms_milli(23, 56, 4, 1_000); -assert_eq!(format!("{:?}", dt), "2015-06-30T23:56:05Z"); - -let dt = Utc.ymd(2015, 6, 30).and_hms(23, 56, 5); -assert_eq!(format!("{:?}", dt), "2015-06-30T23:56:05Z"); -assert_eq!(DateTime::parse_from_rfc3339("2015-06-30T23:56:05Z").unwrap(), dt);
Since Chrono alone cannot determine any existence of leap seconds, -there is absolutely no guarantee that the leap second read has actually happened.
-impl NaiveTime[src]pub fn from_hms(hour: u32, min: u32, sec: u32) -> NaiveTime[src]Makes a new NaiveTime from hour, minute and second.
No leap second is allowed here;
-use NaiveTime::from_hms_* methods with a subsecond parameter instead.
Panics on invalid hour, minute and/or second.
--use chrono::{NaiveTime, Timelike}; - -let t = NaiveTime::from_hms(23, 56, 4); -assert_eq!(t.hour(), 23); -assert_eq!(t.minute(), 56); -assert_eq!(t.second(), 4); -assert_eq!(t.nanosecond(), 0);
pub fn from_hms_opt(hour: u32, min: u32, sec: u32) -> Option<NaiveTime>[src]Makes a new NaiveTime from hour, minute and second.
No leap second is allowed here;
-use NaiveTime::from_hms_*_opt methods with a subsecond parameter instead.
Returns None on invalid hour, minute and/or second.
-use chrono::NaiveTime; - -let from_hms_opt = NaiveTime::from_hms_opt; - -assert!(from_hms_opt(0, 0, 0).is_some()); -assert!(from_hms_opt(23, 59, 59).is_some()); -assert!(from_hms_opt(24, 0, 0).is_none()); -assert!(from_hms_opt(23, 60, 0).is_none()); -assert!(from_hms_opt(23, 59, 60).is_none());
pub fn from_hms_milli(hour: u32, min: u32, sec: u32, milli: u32) -> NaiveTime[src]Makes a new NaiveTime from hour, minute, second and millisecond.
The millisecond part can exceed 1,000 -in order to represent the leap second.
-Panics on invalid hour, minute, second and/or millisecond.
--use chrono::{NaiveTime, Timelike}; - -let t = NaiveTime::from_hms_milli(23, 56, 4, 12); -assert_eq!(t.hour(), 23); -assert_eq!(t.minute(), 56); -assert_eq!(t.second(), 4); -assert_eq!(t.nanosecond(), 12_000_000);
pub fn from_hms_milli_opt(
hour: u32,
min: u32,
sec: u32,
milli: u32
) -> Option<NaiveTime>[src]Makes a new NaiveTime from hour, minute, second and millisecond.
The millisecond part can exceed 1,000 -in order to represent the leap second.
-Returns None on invalid hour, minute, second and/or millisecond.
-use chrono::NaiveTime; - -let from_hmsm_opt = NaiveTime::from_hms_milli_opt; - -assert!(from_hmsm_opt(0, 0, 0, 0).is_some()); -assert!(from_hmsm_opt(23, 59, 59, 999).is_some()); -assert!(from_hmsm_opt(23, 59, 59, 1_999).is_some()); // a leap second after 23:59:59 -assert!(from_hmsm_opt(24, 0, 0, 0).is_none()); -assert!(from_hmsm_opt(23, 60, 0, 0).is_none()); -assert!(from_hmsm_opt(23, 59, 60, 0).is_none()); -assert!(from_hmsm_opt(23, 59, 59, 2_000).is_none());
pub fn from_hms_micro(hour: u32, min: u32, sec: u32, micro: u32) -> NaiveTime[src]Makes a new NaiveTime from hour, minute, second and microsecond.
The microsecond part can exceed 1,000,000 -in order to represent the leap second.
-Panics on invalid hour, minute, second and/or microsecond.
--use chrono::{NaiveTime, Timelike}; - -let t = NaiveTime::from_hms_micro(23, 56, 4, 12_345); -assert_eq!(t.hour(), 23); -assert_eq!(t.minute(), 56); -assert_eq!(t.second(), 4); -assert_eq!(t.nanosecond(), 12_345_000);
pub fn from_hms_micro_opt(
hour: u32,
min: u32,
sec: u32,
micro: u32
) -> Option<NaiveTime>[src]Makes a new NaiveTime from hour, minute, second and microsecond.
The microsecond part can exceed 1,000,000 -in order to represent the leap second.
-Returns None on invalid hour, minute, second and/or microsecond.
-use chrono::NaiveTime; - -let from_hmsu_opt = NaiveTime::from_hms_micro_opt; - -assert!(from_hmsu_opt(0, 0, 0, 0).is_some()); -assert!(from_hmsu_opt(23, 59, 59, 999_999).is_some()); -assert!(from_hmsu_opt(23, 59, 59, 1_999_999).is_some()); // a leap second after 23:59:59 -assert!(from_hmsu_opt(24, 0, 0, 0).is_none()); -assert!(from_hmsu_opt(23, 60, 0, 0).is_none()); -assert!(from_hmsu_opt(23, 59, 60, 0).is_none()); -assert!(from_hmsu_opt(23, 59, 59, 2_000_000).is_none());
pub fn from_hms_nano(hour: u32, min: u32, sec: u32, nano: u32) -> NaiveTime[src]Makes a new NaiveTime from hour, minute, second and nanosecond.
The nanosecond part can exceed 1,000,000,000 -in order to represent the leap second.
-Panics on invalid hour, minute, second and/or nanosecond.
--use chrono::{NaiveTime, Timelike}; - -let t = NaiveTime::from_hms_nano(23, 56, 4, 12_345_678); -assert_eq!(t.hour(), 23); -assert_eq!(t.minute(), 56); -assert_eq!(t.second(), 4); -assert_eq!(t.nanosecond(), 12_345_678);
pub fn from_hms_nano_opt(
hour: u32,
min: u32,
sec: u32,
nano: u32
) -> Option<NaiveTime>[src]Makes a new NaiveTime from hour, minute, second and nanosecond.
The nanosecond part can exceed 1,000,000,000 -in order to represent the leap second.
-Returns None on invalid hour, minute, second and/or nanosecond.
-use chrono::NaiveTime; - -let from_hmsn_opt = NaiveTime::from_hms_nano_opt; - -assert!(from_hmsn_opt(0, 0, 0, 0).is_some()); -assert!(from_hmsn_opt(23, 59, 59, 999_999_999).is_some()); -assert!(from_hmsn_opt(23, 59, 59, 1_999_999_999).is_some()); // a leap second after 23:59:59 -assert!(from_hmsn_opt(24, 0, 0, 0).is_none()); -assert!(from_hmsn_opt(23, 60, 0, 0).is_none()); -assert!(from_hmsn_opt(23, 59, 60, 0).is_none()); -assert!(from_hmsn_opt(23, 59, 59, 2_000_000_000).is_none());
pub fn from_num_seconds_from_midnight(secs: u32, nano: u32) -> NaiveTime[src]Makes a new NaiveTime from the number of seconds since midnight and nanosecond.
The nanosecond part can exceed 1,000,000,000 -in order to represent the leap second.
-Panics on invalid number of seconds and/or nanosecond.
--use chrono::{NaiveTime, Timelike}; - -let t = NaiveTime::from_num_seconds_from_midnight(86164, 12_345_678); -assert_eq!(t.hour(), 23); -assert_eq!(t.minute(), 56); -assert_eq!(t.second(), 4); -assert_eq!(t.nanosecond(), 12_345_678);
pub fn from_num_seconds_from_midnight_opt(
secs: u32,
nano: u32
) -> Option<NaiveTime>[src]Makes a new NaiveTime from the number of seconds since midnight and nanosecond.
The nanosecond part can exceed 1,000,000,000 -in order to represent the leap second.
-Returns None on invalid number of seconds and/or nanosecond.
-use chrono::NaiveTime; - -let from_nsecs_opt = NaiveTime::from_num_seconds_from_midnight_opt; - -assert!(from_nsecs_opt(0, 0).is_some()); -assert!(from_nsecs_opt(86399, 999_999_999).is_some()); -assert!(from_nsecs_opt(86399, 1_999_999_999).is_some()); // a leap second after 23:59:59 -assert!(from_nsecs_opt(86_400, 0).is_none()); -assert!(from_nsecs_opt(86399, 2_000_000_000).is_none());
pub fn parse_from_str(s: &str, fmt: &str) -> ParseResult<NaiveTime>[src]Parses a string with the specified format string and returns a new NaiveTime.
-See the format::strftime module
-on the supported escape sequences.
-use chrono::NaiveTime; - -let parse_from_str = NaiveTime::parse_from_str; - -assert_eq!(parse_from_str("23:56:04", "%H:%M:%S"), - Ok(NaiveTime::from_hms(23, 56, 4))); -assert_eq!(parse_from_str("pm012345.6789", "%p%I%M%S%.f"), - Ok(NaiveTime::from_hms_micro(13, 23, 45, 678_900)));
Date and offset is ignored for the purpose of parsing.
- --assert_eq!(parse_from_str("2014-5-17T12:34:56+09:30", "%Y-%m-%dT%H:%M:%S%z"), - Ok(NaiveTime::from_hms(12, 34, 56)));
Leap seconds are correctly handled by
-treating any time of the form hh:mm:60 as a leap second.
-(This equally applies to the formatting, so the round trip is possible.)
-assert_eq!(parse_from_str("08:59:60.123", "%H:%M:%S%.f"), - Ok(NaiveTime::from_hms_milli(8, 59, 59, 1_123)));
Missing seconds are assumed to be zero, -but out-of-bound times or insufficient fields are errors otherwise.
- --assert_eq!(parse_from_str("7:15", "%H:%M"), - Ok(NaiveTime::from_hms(7, 15, 0))); - -assert!(parse_from_str("04m33s", "%Mm%Ss").is_err()); -assert!(parse_from_str("12", "%H").is_err()); -assert!(parse_from_str("17:60", "%H:%M").is_err()); -assert!(parse_from_str("24:00:00", "%H:%M:%S").is_err());
All parsed fields should be consistent to each other, otherwise it's an error.
-Here %H is for 24-hour clocks, unlike %I,
-and thus can be independently determined without AM/PM.
-assert!(parse_from_str("13:07 AM", "%H:%M %p").is_err());
pub fn overflowing_add_signed(&self, rhs: OldDuration) -> (NaiveTime, i64)[src]Adds given Duration to the current time,
-and also returns the number of seconds
-in the integral number of days ignored from the addition.
-(We cannot return Duration because it is subject to overflow or underflow.)
-use chrono::{Duration, NaiveTime}; - -let from_hms = NaiveTime::from_hms; - -assert_eq!(from_hms(3, 4, 5).overflowing_add_signed(Duration::hours(11)), - (from_hms(14, 4, 5), 0)); -assert_eq!(from_hms(3, 4, 5).overflowing_add_signed(Duration::hours(23)), - (from_hms(2, 4, 5), 86_400)); -assert_eq!(from_hms(3, 4, 5).overflowing_add_signed(Duration::hours(-7)), - (from_hms(20, 4, 5), -86_400));
pub fn overflowing_sub_signed(&self, rhs: OldDuration) -> (NaiveTime, i64)[src]Subtracts given Duration from the current time,
-and also returns the number of seconds
-in the integral number of days ignored from the subtraction.
-(We cannot return Duration because it is subject to overflow or underflow.)
-use chrono::{Duration, NaiveTime}; - -let from_hms = NaiveTime::from_hms; - -assert_eq!(from_hms(3, 4, 5).overflowing_sub_signed(Duration::hours(2)), - (from_hms(1, 4, 5), 0)); -assert_eq!(from_hms(3, 4, 5).overflowing_sub_signed(Duration::hours(17)), - (from_hms(10, 4, 5), 86_400)); -assert_eq!(from_hms(3, 4, 5).overflowing_sub_signed(Duration::hours(-22)), - (from_hms(1, 4, 5), -86_400));
pub fn signed_duration_since(self, rhs: NaiveTime) -> OldDuration[src]Subtracts another NaiveTime from the current time.
-Returns a Duration within +/- 1 day.
-This does not overflow or underflow at all.
As a part of Chrono's leap second handling,
-the subtraction assumes that there is no leap second ever,
-except when any of the NaiveTimes themselves represents a leap second
-in which case the assumption becomes that
-there are exactly one (or two) leap second(s) ever.
-use chrono::{Duration, NaiveTime}; - -let from_hmsm = NaiveTime::from_hms_milli; -let since = NaiveTime::signed_duration_since; - -assert_eq!(since(from_hmsm(3, 5, 7, 900), from_hmsm(3, 5, 7, 900)), - Duration::zero()); -assert_eq!(since(from_hmsm(3, 5, 7, 900), from_hmsm(3, 5, 7, 875)), - Duration::milliseconds(25)); -assert_eq!(since(from_hmsm(3, 5, 7, 900), from_hmsm(3, 5, 6, 925)), - Duration::milliseconds(975)); -assert_eq!(since(from_hmsm(3, 5, 7, 900), from_hmsm(3, 5, 0, 900)), - Duration::seconds(7)); -assert_eq!(since(from_hmsm(3, 5, 7, 900), from_hmsm(3, 0, 7, 900)), - Duration::seconds(5 * 60)); -assert_eq!(since(from_hmsm(3, 5, 7, 900), from_hmsm(0, 5, 7, 900)), - Duration::seconds(3 * 3600)); -assert_eq!(since(from_hmsm(3, 5, 7, 900), from_hmsm(4, 5, 7, 900)), - Duration::seconds(-3600)); -assert_eq!(since(from_hmsm(3, 5, 7, 900), from_hmsm(2, 4, 6, 800)), - Duration::seconds(3600 + 60 + 1) + Duration::milliseconds(100));
Leap seconds are handled, but the subtraction assumes that -there were no other leap seconds happened.
- --assert_eq!(since(from_hmsm(3, 0, 59, 1_000), from_hmsm(3, 0, 59, 0)), - Duration::seconds(1)); -assert_eq!(since(from_hmsm(3, 0, 59, 1_500), from_hmsm(3, 0, 59, 0)), - Duration::milliseconds(1500)); -assert_eq!(since(from_hmsm(3, 0, 59, 1_000), from_hmsm(3, 0, 0, 0)), - Duration::seconds(60)); -assert_eq!(since(from_hmsm(3, 0, 0, 0), from_hmsm(2, 59, 59, 1_000)), - Duration::seconds(1)); -assert_eq!(since(from_hmsm(3, 0, 59, 1_000), from_hmsm(2, 59, 59, 1_000)), - Duration::seconds(61));
pub fn format_with_items<'a, I, B>(&self, items: I) -> DelayedFormat<I> where
I: Iterator<Item = B> + Clone,
B: Borrow<Item<'a>>, [src]Formats the time with the specified formatting items.
-Otherwise it is the same as the ordinary format method.
The Iterator of items should be Cloneable,
-since the resulting DelayedFormat value may be formatted multiple times.
-use chrono::NaiveTime; -use chrono::format::strftime::StrftimeItems; - -let fmt = StrftimeItems::new("%H:%M:%S"); -let t = NaiveTime::from_hms(23, 56, 4); -assert_eq!(t.format_with_items(fmt.clone()).to_string(), "23:56:04"); -assert_eq!(t.format("%H:%M:%S").to_string(), "23:56:04");
The resulting DelayedFormat can be formatted directly via the Display trait.
-assert_eq!(format!("{}", t.format_with_items(fmt)), "23:56:04");
pub fn format<'a>(&self, fmt: &'a str) -> DelayedFormat<StrftimeItems<'a>>[src]Formats the time with the specified format string.
-See the format::strftime module
-on the supported escape sequences.
This returns a DelayedFormat,
-which gets converted to a string only when actual formatting happens.
-You may use the to_string method to get a String,
-or just feed it into print! and other formatting macros.
-(In this way it avoids the redundant memory allocation.)
A wrong format string does not issue an error immediately.
-Rather, converting or formatting the DelayedFormat fails.
-You are recommended to immediately use DelayedFormat for this reason.
-use chrono::NaiveTime; - -let t = NaiveTime::from_hms_nano(23, 56, 4, 12_345_678); -assert_eq!(t.format("%H:%M:%S").to_string(), "23:56:04"); -assert_eq!(t.format("%H:%M:%S%.6f").to_string(), "23:56:04.012345"); -assert_eq!(t.format("%-I:%M %p").to_string(), "11:56 PM");
The resulting DelayedFormat can be formatted directly via the Display trait.
-assert_eq!(format!("{}", t.format("%H:%M:%S")), "23:56:04"); -assert_eq!(format!("{}", t.format("%H:%M:%S%.6f")), "23:56:04.012345"); -assert_eq!(format!("{}", t.format("%-I:%M %p")), "11:56 PM");
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.
-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));
type Output = NaiveTimeThe resulting type after applying the + operator.
fn add(self, rhs: OldDuration) -> NaiveTime[src]impl Add<FixedOffset> for NaiveTime[src]type Output = NaiveTimeThe resulting type after applying the + operator.
fn add(self, rhs: FixedOffset) -> NaiveTime[src]impl AddAssign<Duration> for NaiveTime[src]fn add_assign(&mut self, rhs: OldDuration)[src]impl Clone for NaiveTime[src]impl Copy for NaiveTime[src]impl Debug for NaiveTime[src]The Debug output of the naive time t is the same as
-t.format("%H:%M:%S%.f").
The string printed can be readily parsed via the parse method on str.
It should be noted that, for leap seconds not on the minute boundary, -it may print a representation not distinguishable from non-leap seconds. -This doesn't matter in practice, since such leap seconds never happened. -(By the time of the first leap second on 1972-06-30, -every time zone offset around the world has standardized to the 5-minute alignment.)
--use chrono::NaiveTime; - -assert_eq!(format!("{:?}", NaiveTime::from_hms(23, 56, 4)), "23:56:04"); -assert_eq!(format!("{:?}", NaiveTime::from_hms_milli(23, 56, 4, 12)), "23:56:04.012"); -assert_eq!(format!("{:?}", NaiveTime::from_hms_micro(23, 56, 4, 1234)), "23:56:04.001234"); -assert_eq!(format!("{:?}", NaiveTime::from_hms_nano(23, 56, 4, 123456)), "23:56:04.000123456");
Leap seconds may also be used.
- --assert_eq!(format!("{:?}", NaiveTime::from_hms_milli(6, 59, 59, 1_500)), "06:59:60.500");
impl Display for NaiveTime[src]The Display output of the naive time t is the same as
-t.format("%H:%M:%S%.f").
The string printed can be readily parsed via the parse method on str.
It should be noted that, for leap seconds not on the minute boundary, -it may print a representation not distinguishable from non-leap seconds. -This doesn't matter in practice, since such leap seconds never happened. -(By the time of the first leap second on 1972-06-30, -every time zone offset around the world has standardized to the 5-minute alignment.)
--use chrono::NaiveTime; - -assert_eq!(format!("{}", NaiveTime::from_hms(23, 56, 4)), "23:56:04"); -assert_eq!(format!("{}", NaiveTime::from_hms_milli(23, 56, 4, 12)), "23:56:04.012"); -assert_eq!(format!("{}", NaiveTime::from_hms_micro(23, 56, 4, 1234)), "23:56:04.001234"); -assert_eq!(format!("{}", NaiveTime::from_hms_nano(23, 56, 4, 123456)), "23:56:04.000123456");
Leap seconds may also be used.
- --assert_eq!(format!("{}", NaiveTime::from_hms_milli(6, 59, 59, 1_500)), "06:59:60.500");
impl Eq for NaiveTime[src]impl FromStr for NaiveTime[src]Parsing a str into a NaiveTime uses the same format,
-%H:%M:%S%.f, as in Debug and Display.
-use chrono::NaiveTime; - -let t = NaiveTime::from_hms(23, 56, 4); -assert_eq!("23:56:04".parse::<NaiveTime>(), Ok(t)); - -let t = NaiveTime::from_hms_nano(23, 56, 4, 12_345_678); -assert_eq!("23:56:4.012345678".parse::<NaiveTime>(), Ok(t)); - -let t = NaiveTime::from_hms_nano(23, 59, 59, 1_234_567_890); // leap second -assert_eq!("23:59:60.23456789".parse::<NaiveTime>(), Ok(t)); - -assert!("foo".parse::<NaiveTime>().is_err());
type Err = ParseErrorThe associated error which can be returned from parsing.
-fn from_str(s: &str) -> ParseResult<NaiveTime>[src]impl Hash for NaiveTime[src]NaiveTime can be used as a key to the hash maps (in principle).
Practically this also takes account of fractional seconds, so it is not recommended. -(For the obvious reason this also distinguishes leap seconds from non-leap seconds.)
-fn hash<H: Hasher>(&self, state: &mut H)[src]pub fn hash_slice<H>(data: &[Self], state: &mut H) where
H: Hasher, 1.3.0[src]impl Ord for NaiveTime[src]fn cmp(&self, other: &NaiveTime) -> Ordering[src]#[must_use]pub fn max(self, other: Self) -> Self1.21.0[src]#[must_use]pub fn min(self, other: Self) -> Self1.21.0[src]#[must_use]pub fn clamp(self, min: Self, max: Self) -> Self1.50.0[src]impl PartialEq<NaiveTime> for NaiveTime[src]impl PartialOrd<NaiveTime> for NaiveTime[src]fn partial_cmp(&self, other: &NaiveTime) -> Option<Ordering>[src]fn lt(&self, other: &NaiveTime) -> bool[src]fn le(&self, other: &NaiveTime) -> bool[src]fn gt(&self, other: &NaiveTime) -> bool[src]fn ge(&self, other: &NaiveTime) -> bool[src]impl StructuralEq for NaiveTime[src]impl StructuralPartialEq 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.
-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));
type Output = NaiveTimeThe resulting type after applying the - operator.
fn sub(self, rhs: OldDuration) -> NaiveTime[src]impl Sub<FixedOffset> for NaiveTime[src]type Output = NaiveTimeThe resulting type after applying the - operator.
fn sub(self, rhs: FixedOffset) -> NaiveTime[src]impl Sub<NaiveTime> for NaiveTime[src]Subtracts another NaiveTime from the current time.
-Returns a Duration within +/- 1 day.
-This does not overflow or underflow at all.
As a part of Chrono's leap second handling,
-the subtraction assumes that there is no leap second ever,
-except when any of the NaiveTimes themselves represents a leap second
-in which case the assumption becomes that
-there are exactly one (or two) leap second(s) ever.
The implementation is a wrapper around
-NaiveTime::signed_duration_since.
-use chrono::{Duration, NaiveTime}; - -let from_hmsm = NaiveTime::from_hms_milli; - -assert_eq!(from_hmsm(3, 5, 7, 900) - from_hmsm(3, 5, 7, 900), Duration::zero()); -assert_eq!(from_hmsm(3, 5, 7, 900) - from_hmsm(3, 5, 7, 875), Duration::milliseconds(25)); -assert_eq!(from_hmsm(3, 5, 7, 900) - from_hmsm(3, 5, 6, 925), Duration::milliseconds(975)); -assert_eq!(from_hmsm(3, 5, 7, 900) - from_hmsm(3, 5, 0, 900), Duration::seconds(7)); -assert_eq!(from_hmsm(3, 5, 7, 900) - from_hmsm(3, 0, 7, 900), Duration::seconds(5 * 60)); -assert_eq!(from_hmsm(3, 5, 7, 900) - from_hmsm(0, 5, 7, 900), Duration::seconds(3 * 3600)); -assert_eq!(from_hmsm(3, 5, 7, 900) - from_hmsm(4, 5, 7, 900), Duration::seconds(-3600)); -assert_eq!(from_hmsm(3, 5, 7, 900) - from_hmsm(2, 4, 6, 800), - Duration::seconds(3600 + 60 + 1) + Duration::milliseconds(100));
Leap seconds are handled, but the subtraction assumes that -there were no other leap seconds happened.
- --assert_eq!(from_hmsm(3, 0, 59, 1_000) - from_hmsm(3, 0, 59, 0), Duration::seconds(1)); -assert_eq!(from_hmsm(3, 0, 59, 1_500) - from_hmsm(3, 0, 59, 0), - Duration::milliseconds(1500)); -assert_eq!(from_hmsm(3, 0, 59, 1_000) - from_hmsm(3, 0, 0, 0), Duration::seconds(60)); -assert_eq!(from_hmsm(3, 0, 0, 0) - from_hmsm(2, 59, 59, 1_000), Duration::seconds(1)); -assert_eq!(from_hmsm(3, 0, 59, 1_000) - from_hmsm(2, 59, 59, 1_000), - Duration::seconds(61));
type Output = OldDurationThe resulting type after applying the - operator.
fn sub(self, rhs: NaiveTime) -> OldDuration[src]impl SubAssign<Duration> for NaiveTime[src]fn sub_assign(&mut self, rhs: OldDuration)[src]impl Timelike for NaiveTime[src]fn hour(&self) -> u32[src]Returns the hour number from 0 to 23.
--use chrono::{NaiveTime, Timelike}; - -assert_eq!(NaiveTime::from_hms(0, 0, 0).hour(), 0); -assert_eq!(NaiveTime::from_hms_nano(23, 56, 4, 12_345_678).hour(), 23);
fn minute(&self) -> u32[src]Returns the minute number from 0 to 59.
--use chrono::{NaiveTime, Timelike}; - -assert_eq!(NaiveTime::from_hms(0, 0, 0).minute(), 0); -assert_eq!(NaiveTime::from_hms_nano(23, 56, 4, 12_345_678).minute(), 56);
fn second(&self) -> u32[src]Returns the second number from 0 to 59.
--use chrono::{NaiveTime, Timelike}; - -assert_eq!(NaiveTime::from_hms(0, 0, 0).second(), 0); -assert_eq!(NaiveTime::from_hms_nano(23, 56, 4, 12_345_678).second(), 4);
This method never returns 60 even when it is a leap second. -(Why?) -Use the proper formatting method to get a human-readable representation.
- --let leap = NaiveTime::from_hms_milli(23, 59, 59, 1_000); -assert_eq!(leap.second(), 59); -assert_eq!(leap.format("%H:%M:%S").to_string(), "23:59:60");
fn nanosecond(&self) -> u32[src]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.
--use chrono::{NaiveTime, Timelike}; - -assert_eq!(NaiveTime::from_hms(0, 0, 0).nanosecond(), 0); -assert_eq!(NaiveTime::from_hms_nano(23, 56, 4, 12_345_678).nanosecond(), 12_345_678);
Leap seconds may have seemingly out-of-range return values.
-You can reduce the range with time.nanosecond() % 1_000_000_000, or
-use the proper formatting method to get a human-readable representation.
-let leap = NaiveTime::from_hms_milli(23, 59, 59, 1_000); -assert_eq!(leap.nanosecond(), 1_000_000_000); -assert_eq!(leap.format("%H:%M:%S%.9f").to_string(), "23:59:60.000000000");
fn with_hour(&self, hour: u32) -> Option<NaiveTime>[src]Makes a new NaiveTime with the hour number changed.
Returns None when the resulting NaiveTime would be invalid.
-use chrono::{NaiveTime, Timelike}; - -let dt = NaiveTime::from_hms_nano(23, 56, 4, 12_345_678); -assert_eq!(dt.with_hour(7), Some(NaiveTime::from_hms_nano(7, 56, 4, 12_345_678))); -assert_eq!(dt.with_hour(24), None);
fn with_minute(&self, min: u32) -> Option<NaiveTime>[src]Makes a new NaiveTime with the minute number changed.
Returns None when the resulting NaiveTime would be invalid.
-use chrono::{NaiveTime, Timelike}; - -let dt = NaiveTime::from_hms_nano(23, 56, 4, 12_345_678); -assert_eq!(dt.with_minute(45), Some(NaiveTime::from_hms_nano(23, 45, 4, 12_345_678))); -assert_eq!(dt.with_minute(60), None);
fn with_second(&self, sec: u32) -> Option<NaiveTime>[src]Makes a new NaiveTime with the second number changed.
Returns None when the resulting NaiveTime would be invalid.
-As with the second method,
-the input range is restricted to 0 through 59.
-use chrono::{NaiveTime, Timelike}; - -let dt = NaiveTime::from_hms_nano(23, 56, 4, 12_345_678); -assert_eq!(dt.with_second(17), Some(NaiveTime::from_hms_nano(23, 56, 17, 12_345_678))); -assert_eq!(dt.with_second(60), None);
fn with_nanosecond(&self, nano: u32) -> Option<NaiveTime>[src]Makes a new NaiveTime with nanoseconds since the whole non-leap second changed.
Returns None when the resulting NaiveTime would be invalid.
-As with the nanosecond method,
-the input range can exceed 1,000,000,000 for leap seconds.
-use chrono::{NaiveTime, Timelike}; - -let dt = NaiveTime::from_hms_nano(23, 56, 4, 12_345_678); -assert_eq!(dt.with_nanosecond(333_333_333), - Some(NaiveTime::from_hms_nano(23, 56, 4, 333_333_333))); -assert_eq!(dt.with_nanosecond(2_000_000_000), None);
Leap seconds can theoretically follow any whole second. -The following would be a proper leap second at the time zone offset of UTC-00:03:57 -(there are several historical examples comparable to this "non-sense" offset), -and therefore is allowed.
- --assert_eq!(dt.with_nanosecond(1_333_333_333), - Some(NaiveTime::from_hms_nano(23, 56, 4, 1_333_333_333)));
fn num_seconds_from_midnight(&self) -> u32[src]Returns the number of non-leap seconds past the last midnight.
--use chrono::{NaiveTime, Timelike}; - -assert_eq!(NaiveTime::from_hms(1, 2, 3).num_seconds_from_midnight(), - 3723); -assert_eq!(NaiveTime::from_hms_nano(23, 56, 4, 12_345_678).num_seconds_from_midnight(), - 86164); -assert_eq!(NaiveTime::from_hms_milli(23, 59, 59, 1_000).num_seconds_from_midnight(), - 86399);
fn hour12(&self) -> (bool, u32)[src]impl RefUnwindSafe for NaiveTime[src]impl Send for NaiveTime[src]impl Sync for NaiveTime[src]impl Unpin for NaiveTime[src]impl UnwindSafe for NaiveTime[src]impl<T> Any for T where
T: 'static + ?Sized, [src]impl<T> Borrow<T> for T where
T: ?Sized, [src]impl<T> BorrowMut<T> for T where
T: ?Sized, [src]pub fn borrow_mut(&mut self) -> &mut T[src]impl<T> From<T> for T[src]impl<T, U> Into<U> for T where
U: From<T>, [src]impl<T> ToOwned for T where
T: Clone, [src]type Owned = TThe resulting type after obtaining ownership.
-pub fn to_owned(&self) -> T[src]pub fn clone_into(&self, target: &mut T)[src]impl<T> ToString for T where
T: Display + ?Sized, [src]impl<T, U> TryFrom<U> for T where
U: Into<T>, [src]type Error = InfallibleThe type returned in the event of a conversion error.
-pub fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]impl<T, U> TryInto<U> for T where
U: TryFrom<T>, [src]Redirecting to ../../../chrono/naive/struct.NaiveTime.html...
- - - \ No newline at end of file diff --git a/docs/chrono/offset/enum.LocalResult.html b/docs/chrono/offset/enum.LocalResult.html deleted file mode 100644 index f1d5770a..00000000 --- a/docs/chrono/offset/enum.LocalResult.html +++ /dev/null @@ -1,60 +0,0 @@ -The conversion result from the local time to the timezone-aware datetime types.
-Given local time representation is invalid. -This can occur when, for example, the positive timezone transition.
-Given local time representation has a single unique result.
-Given local time representation has multiple results and thus ambiguous. -This can occur when, for example, the negative timezone transition.
-impl<T> LocalResult<T>[src]pub fn single(self) -> Option<T>[src]Returns Some only when the conversion result is unique, or None otherwise.
pub fn earliest(self) -> Option<T>[src]Returns Some for the earliest possible conversion result, or None if none.
pub fn latest(self) -> Option<T>[src]Returns Some for the latest possible conversion result, or None if none.
pub fn map<U, F: FnMut(T) -> U>(self, f: F) -> LocalResult<U>[src]Maps a LocalResult<T> into LocalResult<U> with given function.
impl<Tz: TimeZone> LocalResult<Date<Tz>>[src]pub fn and_time(self, time: NaiveTime) -> LocalResult<DateTime<Tz>>[src]Makes a new DateTime from the current date and given NaiveTime.
-The offset in the current date is preserved.
Propagates any error. Ambiguous result would be discarded.
-pub fn and_hms_opt(
self,
hour: u32,
min: u32,
sec: u32
) -> LocalResult<DateTime<Tz>>[src]Makes a new DateTime from the current date, hour, minute and second.
-The offset in the current date is preserved.
Propagates any error. Ambiguous result would be discarded.
-pub fn and_hms_milli_opt(
self,
hour: u32,
min: u32,
sec: u32,
milli: u32
) -> LocalResult<DateTime<Tz>>[src]Makes a new DateTime from the current date, hour, minute, second and millisecond.
-The millisecond part can exceed 1,000 in order to represent the leap second.
-The offset in the current date is preserved.
Propagates any error. Ambiguous result would be discarded.
-pub fn and_hms_micro_opt(
self,
hour: u32,
min: u32,
sec: u32,
micro: u32
) -> LocalResult<DateTime<Tz>>[src]Makes a new DateTime from the current date, hour, minute, second and microsecond.
-The microsecond part can exceed 1,000,000 in order to represent the leap second.
-The offset in the current date is preserved.
Propagates any error. Ambiguous result would be discarded.
-pub fn and_hms_nano_opt(
self,
hour: u32,
min: u32,
sec: u32,
nano: u32
) -> LocalResult<DateTime<Tz>>[src]Makes a new DateTime from the current date, hour, minute, second and nanosecond.
-The nanosecond part can exceed 1,000,000,000 in order to represent the leap second.
-The offset in the current date is preserved.
Propagates any error. Ambiguous result would be discarded.
-impl<T: Debug> LocalResult<T>[src]impl<T: Clone> Clone for LocalResult<T>[src]fn clone(&self) -> LocalResult<T>[src]pub fn clone_from(&mut self, source: &Self)1.0.0[src]impl<T: Copy> Copy for LocalResult<T>[src]impl<T: Debug> Debug for LocalResult<T>[src]impl<T: Eq> Eq for LocalResult<T>[src]impl<T: Hash> Hash for LocalResult<T>[src]fn hash<__H: Hasher>(&self, state: &mut __H)[src]pub fn hash_slice<H>(data: &[Self], state: &mut H) where
H: Hasher, 1.3.0[src]impl<T: PartialEq> PartialEq<LocalResult<T>> for LocalResult<T>[src]fn eq(&self, other: &LocalResult<T>) -> bool[src]fn ne(&self, other: &LocalResult<T>) -> bool[src]impl<T> StructuralEq for LocalResult<T>[src]impl<T> StructuralPartialEq for LocalResult<T>[src]impl<T> RefUnwindSafe for LocalResult<T> where
T: RefUnwindSafe, [src]impl<T> Send for LocalResult<T> where
T: Send, [src]impl<T> Sync for LocalResult<T> where
T: Sync, [src]impl<T> Unpin for LocalResult<T> where
T: Unpin, [src]impl<T> UnwindSafe for LocalResult<T> where
T: UnwindSafe, [src]impl<T> Any for T where
T: 'static + ?Sized, [src]impl<T> Borrow<T> for T where
T: ?Sized, [src]impl<T> BorrowMut<T> for T where
T: ?Sized, [src]pub fn borrow_mut(&mut self) -> &mut T[src]impl<T> From<T> for T[src]impl<T, U> Into<U> for T where
U: From<T>, [src]impl<T> ToOwned for T where
T: Clone, [src]type Owned = TThe resulting type after obtaining ownership.
-pub fn to_owned(&self) -> T[src]pub fn clone_into(&self, target: &mut T)[src]impl<T, U> TryFrom<U> for T where
U: Into<T>, [src]type Error = InfallibleThe type returned in the event of a conversion error.
-pub fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]impl<T, U> TryInto<U> for T where
U: TryFrom<T>, [src]Redirecting to ../../../chrono/offset/struct.FixedOffset.html...
- - - \ No newline at end of file diff --git a/docs/chrono/offset/index.html b/docs/chrono/offset/index.html deleted file mode 100644 index cfed349f..00000000 --- a/docs/chrono/offset/index.html +++ /dev/null @@ -1,29 +0,0 @@ -The time zone, which calculates offsets from the local time to UTC.
-There are four operations provided by the TimeZone trait:
NaiveDateTime to DateTime<Tz>NaiveDateTime to DateTime<Tz>DateTime<Tz> to the local NaiveDateTimeDateTime<Tz> objects from various offsets1 is used for constructors. 2 is used for the with_timezone method of date and time types.
-3 is used for other methods, e.g. year() or format(), and provided by an associated type
-which implements Offset (which then passed to TimeZone for actual implementations).
-Technically speaking TimeZone has a total knowledge about given timescale,
-but Offset is used as a cache to avoid the repeated conversion
-and provides implementations for 1 and 3.
-An TimeZone instance can be reconstructed from the corresponding Offset instance.
| FixedOffset | The time zone with fixed offset, from UTC-23:59:59 to UTC+23:59:59. - |
| Local | The local timescale. This is implemented via the standard |
| Utc | The UTC time zone. This is the most efficient time zone when you don't need the local time. -It is also used as an offset (which is also a dummy type). - |
| LocalResult | The conversion result from the local time to the timezone-aware datetime types. - |
| Offset | The offset from the local time to UTC. - |
| TimeZone | The time zone. - |
Redirecting to ../../../chrono/offset/struct.Local.html...
- - - \ No newline at end of file diff --git a/docs/chrono/offset/sidebar-items.js b/docs/chrono/offset/sidebar-items.js deleted file mode 100644 index 6e689563..00000000 --- a/docs/chrono/offset/sidebar-items.js +++ /dev/null @@ -1 +0,0 @@ -initSidebarItems({"enum":[["LocalResult","The conversion result from the local time to the timezone-aware datetime types."]],"struct":[["FixedOffset","The time zone with fixed offset, from UTC-23:59:59 to UTC+23:59:59."],["Local","The local timescale. This is implemented via the standard `time` crate."],["Utc","The UTC time zone. This is the most efficient time zone when you don't need the local time. It is also used as an offset (which is also a dummy type)."]],"trait":[["Offset","The offset from the local time to UTC."],["TimeZone","The time zone."]]}); \ No newline at end of file diff --git a/docs/chrono/offset/struct.FixedOffset.html b/docs/chrono/offset/struct.FixedOffset.html deleted file mode 100644 index 3fbb65f4..00000000 --- a/docs/chrono/offset/struct.FixedOffset.html +++ /dev/null @@ -1,119 +0,0 @@ -The time zone with fixed offset, from UTC-23:59:59 to UTC+23:59:59.
-Using the TimeZone methods
-on a FixedOffset struct is the preferred way to construct
-DateTime<FixedOffset> instances. See the east and
-west methods for examples.
impl FixedOffset[src]pub fn east(secs: i32) -> FixedOffset[src]Makes a new FixedOffset for the Eastern Hemisphere with given timezone difference.
-The negative secs means the Western Hemisphere.
Panics on the out-of-bound secs.
-use chrono::{FixedOffset, TimeZone}; -let hour = 3600; -let datetime = FixedOffset::east(5 * hour).ymd(2016, 11, 08) - .and_hms(0, 0, 0); -assert_eq!(&datetime.to_rfc3339(), "2016-11-08T00:00:00+05:00")
pub fn east_opt(secs: i32) -> Option<FixedOffset>[src]Makes a new FixedOffset for the Eastern Hemisphere with given timezone difference.
-The negative secs means the Western Hemisphere.
Returns None on the out-of-bound secs.
pub fn west(secs: i32) -> FixedOffset[src]Makes a new FixedOffset for the Western Hemisphere with given timezone difference.
-The negative secs means the Eastern Hemisphere.
Panics on the out-of-bound secs.
-use chrono::{FixedOffset, TimeZone}; -let hour = 3600; -let datetime = FixedOffset::west(5 * hour).ymd(2016, 11, 08) - .and_hms(0, 0, 0); -assert_eq!(&datetime.to_rfc3339(), "2016-11-08T00:00:00-05:00")
pub fn west_opt(secs: i32) -> Option<FixedOffset>[src]Makes a new FixedOffset for the Western Hemisphere with given timezone difference.
-The negative secs means the Eastern Hemisphere.
Returns None on the out-of-bound secs.
pub fn local_minus_utc(&self) -> i32[src]Returns the number of seconds to add to convert from UTC to the local time.
-pub fn utc_minus_local(&self) -> i32[src]Returns the number of seconds to add to convert from the local time to UTC.
-impl Add<FixedOffset> for NaiveTime[src]type Output = NaiveTimeThe resulting type after applying the + operator.
fn add(self, rhs: FixedOffset) -> NaiveTime[src]impl Add<FixedOffset> for NaiveDateTime[src]type Output = NaiveDateTimeThe resulting type after applying the + operator.
fn add(self, rhs: FixedOffset) -> NaiveDateTime[src]impl<Tz: TimeZone> Add<FixedOffset> for DateTime<Tz>[src]type Output = DateTime<Tz>The resulting type after applying the + operator.
fn add(self, rhs: FixedOffset) -> DateTime<Tz>[src]impl Clone for FixedOffset[src]fn clone(&self) -> FixedOffset[src]pub fn clone_from(&mut self, source: &Self)1.0.0[src]impl Copy for FixedOffset[src]impl Debug for FixedOffset[src]impl Display for FixedOffset[src]impl Eq for FixedOffset[src]impl Hash for FixedOffset[src]fn hash<__H: Hasher>(&self, state: &mut __H)[src]pub fn hash_slice<H>(data: &[Self], state: &mut H) where
H: Hasher, 1.3.0[src]impl Offset for FixedOffset[src]fn fix(&self) -> FixedOffset[src]impl PartialEq<FixedOffset> for FixedOffset[src]fn eq(&self, other: &FixedOffset) -> bool[src]fn ne(&self, other: &FixedOffset) -> bool[src]impl StructuralEq for FixedOffset[src]impl StructuralPartialEq for FixedOffset[src]impl Sub<FixedOffset> for NaiveTime[src]type Output = NaiveTimeThe resulting type after applying the - operator.
fn sub(self, rhs: FixedOffset) -> NaiveTime[src]impl Sub<FixedOffset> for NaiveDateTime[src]type Output = NaiveDateTimeThe resulting type after applying the - operator.
fn sub(self, rhs: FixedOffset) -> NaiveDateTime[src]impl<Tz: TimeZone> Sub<FixedOffset> for DateTime<Tz>[src]type Output = DateTime<Tz>The resulting type after applying the - operator.
fn sub(self, rhs: FixedOffset) -> DateTime<Tz>[src]impl TimeZone for FixedOffset[src]type Offset = FixedOffsetAn associated offset type.
-This type is used to store the actual offset in date and time types.
-The original TimeZone value can be recovered via TimeZone::from_offset. Read more
fn from_offset(offset: &FixedOffset) -> FixedOffset[src]fn offset_from_local_date(&self, _local: &NaiveDate) -> LocalResult<FixedOffset>[src]fn offset_from_local_datetime(
&self,
_local: &NaiveDateTime
) -> LocalResult<FixedOffset>[src]fn offset_from_utc_date(&self, _utc: &NaiveDate) -> FixedOffset[src]fn offset_from_utc_datetime(&self, _utc: &NaiveDateTime) -> FixedOffset[src]fn ymd(&self, year: i32, month: u32, day: u32) -> Date<Self>[src]fn ymd_opt(&self, year: i32, month: u32, day: u32) -> LocalResult<Date<Self>>[src]fn yo(&self, year: i32, ordinal: u32) -> Date<Self>[src]fn yo_opt(&self, year: i32, ordinal: u32) -> LocalResult<Date<Self>>[src]fn isoywd(&self, year: i32, week: u32, weekday: Weekday) -> Date<Self>[src]fn isoywd_opt(
&self,
year: i32,
week: u32,
weekday: Weekday
) -> LocalResult<Date<Self>>[src]fn timestamp(&self, secs: i64, nsecs: u32) -> DateTime<Self>[src]fn timestamp_opt(&self, secs: i64, nsecs: u32) -> LocalResult<DateTime<Self>>[src]fn timestamp_millis(&self, millis: i64) -> DateTime<Self>[src]fn timestamp_millis_opt(&self, millis: i64) -> LocalResult<DateTime<Self>>[src]fn timestamp_nanos(&self, nanos: i64) -> DateTime<Self>[src]fn datetime_from_str(&self, s: &str, fmt: &str) -> ParseResult<DateTime<Self>>[src]fn from_local_date(&self, local: &NaiveDate) -> LocalResult<Date<Self>>[src]fn from_local_datetime(
&self,
local: &NaiveDateTime
) -> LocalResult<DateTime<Self>>[src]fn from_utc_date(&self, utc: &NaiveDate) -> Date<Self>[src]fn from_utc_datetime(&self, utc: &NaiveDateTime) -> DateTime<Self>[src]impl RefUnwindSafe for FixedOffset[src]impl Send for FixedOffset[src]impl Sync for FixedOffset[src]impl Unpin for FixedOffset[src]impl UnwindSafe for FixedOffset[src]impl<T> Any for T where
T: 'static + ?Sized, [src]impl<T> Borrow<T> for T where
T: ?Sized, [src]impl<T> BorrowMut<T> for T where
T: ?Sized, [src]pub fn borrow_mut(&mut self) -> &mut T[src]impl<T> From<T> for T[src]impl<T, U> Into<U> for T where
U: From<T>, [src]impl<T> ToOwned for T where
T: Clone, [src]type Owned = TThe resulting type after obtaining ownership.
-pub fn to_owned(&self) -> T[src]pub fn clone_into(&self, target: &mut T)[src]impl<T> ToString for T where
T: Display + ?Sized, [src]impl<T, U> TryFrom<U> for T where
U: Into<T>, [src]type Error = InfallibleThe type returned in the event of a conversion error.
-pub fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]impl<T, U> TryInto<U> for T where
U: TryFrom<T>, [src]The local timescale. This is implemented via the standard time crate.
Using the TimeZone methods
-on the Local struct is the preferred way to construct DateTime<Local>
-instances.
-use chrono::{Local, DateTime, TimeZone}; - -let dt: DateTime<Local> = Local::now(); -let dt: DateTime<Local> = Local.timestamp(0, 0);
impl Local[src]pub fn today() -> Date<Local>[src]Returns a Date which corresponds to the current date.
pub fn now() -> DateTime<Local>[src]Returns a DateTime which corresponds to the current date.
impl Clone for Local[src]impl Copy for Local[src]impl Debug for Local[src]impl TimeZone for Local[src]type Offset = FixedOffsetAn associated offset type.
-This type is used to store the actual offset in date and time types.
-The original TimeZone value can be recovered via TimeZone::from_offset. Read more
fn from_offset(_offset: &FixedOffset) -> Local[src]fn offset_from_local_date(&self, local: &NaiveDate) -> LocalResult<FixedOffset>[src]fn offset_from_local_datetime(
&self,
local: &NaiveDateTime
) -> LocalResult<FixedOffset>[src]fn offset_from_utc_date(&self, utc: &NaiveDate) -> FixedOffset[src]fn offset_from_utc_datetime(&self, utc: &NaiveDateTime) -> FixedOffset[src]fn from_local_date(&self, local: &NaiveDate) -> LocalResult<Date<Local>>[src]fn from_local_datetime(
&self,
local: &NaiveDateTime
) -> LocalResult<DateTime<Local>>[src]fn from_utc_date(&self, utc: &NaiveDate) -> Date<Local>[src]fn from_utc_datetime(&self, utc: &NaiveDateTime) -> DateTime<Local>[src]fn ymd(&self, year: i32, month: u32, day: u32) -> Date<Self>[src]fn ymd_opt(&self, year: i32, month: u32, day: u32) -> LocalResult<Date<Self>>[src]fn yo(&self, year: i32, ordinal: u32) -> Date<Self>[src]fn yo_opt(&self, year: i32, ordinal: u32) -> LocalResult<Date<Self>>[src]fn isoywd(&self, year: i32, week: u32, weekday: Weekday) -> Date<Self>[src]fn isoywd_opt(
&self,
year: i32,
week: u32,
weekday: Weekday
) -> LocalResult<Date<Self>>[src]fn timestamp(&self, secs: i64, nsecs: u32) -> DateTime<Self>[src]fn timestamp_opt(&self, secs: i64, nsecs: u32) -> LocalResult<DateTime<Self>>[src]fn timestamp_millis(&self, millis: i64) -> DateTime<Self>[src]fn timestamp_millis_opt(&self, millis: i64) -> LocalResult<DateTime<Self>>[src]fn timestamp_nanos(&self, nanos: i64) -> DateTime<Self>[src]fn datetime_from_str(&self, s: &str, fmt: &str) -> ParseResult<DateTime<Self>>[src]impl RefUnwindSafe for Local[src]impl Send for Local[src]impl Sync for Local[src]impl Unpin for Local[src]impl UnwindSafe for Local[src]impl<T> Any for T where
T: 'static + ?Sized, [src]impl<T> Borrow<T> for T where
T: ?Sized, [src]impl<T> BorrowMut<T> for T where
T: ?Sized, [src]pub fn borrow_mut(&mut self) -> &mut T[src]impl<T> From<T> for T[src]impl<T, U> Into<U> for T where
U: From<T>, [src]impl<T> ToOwned for T where
T: Clone, [src]type Owned = TThe resulting type after obtaining ownership.
-pub fn to_owned(&self) -> T[src]pub fn clone_into(&self, target: &mut T)[src]impl<T, U> TryFrom<U> for T where
U: Into<T>, [src]type Error = InfallibleThe type returned in the event of a conversion error.
-pub fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]impl<T, U> TryInto<U> for T where
U: TryFrom<T>, [src]The UTC time zone. This is the most efficient time zone when you don't need the local time. -It is also used as an offset (which is also a dummy type).
-Using the TimeZone methods
-on the UTC struct is the preferred way to construct DateTime<Utc>
-instances.
-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); -assert_eq!(Utc.ymd(1970, 1, 1).and_hms(0, 1, 1), dt);
impl Utc[src]pub fn today() -> Date<Utc>[src]Returns a Date which corresponds to the current date.
pub fn now() -> DateTime<Utc>[src]Returns a DateTime which corresponds to the current date.
impl Clone for Utc[src]impl Copy for Utc[src]impl Debug for Utc[src]impl Display for Utc[src]impl Eq for Utc[src]impl Offset for Utc[src]fn fix(&self) -> FixedOffset[src]impl PartialEq<Utc> for Utc[src]impl StructuralEq for Utc[src]impl StructuralPartialEq for Utc[src]impl TimeZone for Utc[src]type Offset = UtcAn associated offset type.
-This type is used to store the actual offset in date and time types.
-The original TimeZone value can be recovered via TimeZone::from_offset. Read more
fn from_offset(_state: &Utc) -> Utc[src]fn offset_from_local_date(&self, _local: &NaiveDate) -> LocalResult<Utc>[src]fn offset_from_local_datetime(&self, _local: &NaiveDateTime) -> LocalResult<Utc>[src]fn offset_from_utc_date(&self, _utc: &NaiveDate) -> Utc[src]fn offset_from_utc_datetime(&self, _utc: &NaiveDateTime) -> Utc[src]fn ymd(&self, year: i32, month: u32, day: u32) -> Date<Self>[src]fn ymd_opt(&self, year: i32, month: u32, day: u32) -> LocalResult<Date<Self>>[src]fn yo(&self, year: i32, ordinal: u32) -> Date<Self>[src]fn yo_opt(&self, year: i32, ordinal: u32) -> LocalResult<Date<Self>>[src]fn isoywd(&self, year: i32, week: u32, weekday: Weekday) -> Date<Self>[src]fn isoywd_opt(
&self,
year: i32,
week: u32,
weekday: Weekday
) -> LocalResult<Date<Self>>[src]fn timestamp(&self, secs: i64, nsecs: u32) -> DateTime<Self>[src]fn timestamp_opt(&self, secs: i64, nsecs: u32) -> LocalResult<DateTime<Self>>[src]fn timestamp_millis(&self, millis: i64) -> DateTime<Self>[src]fn timestamp_millis_opt(&self, millis: i64) -> LocalResult<DateTime<Self>>[src]fn timestamp_nanos(&self, nanos: i64) -> DateTime<Self>[src]fn datetime_from_str(&self, s: &str, fmt: &str) -> ParseResult<DateTime<Self>>[src]fn from_local_date(&self, local: &NaiveDate) -> LocalResult<Date<Self>>[src]fn from_local_datetime(
&self,
local: &NaiveDateTime
) -> LocalResult<DateTime<Self>>[src]fn from_utc_date(&self, utc: &NaiveDate) -> Date<Self>[src]fn from_utc_datetime(&self, utc: &NaiveDateTime) -> DateTime<Self>[src]impl RefUnwindSafe for Utc[src]impl Send for Utc[src]impl Sync for Utc[src]impl Unpin for Utc[src]impl UnwindSafe for Utc[src]impl<T> Any for T where
T: 'static + ?Sized, [src]impl<T> Borrow<T> for T where
T: ?Sized, [src]impl<T> BorrowMut<T> for T where
T: ?Sized, [src]pub fn borrow_mut(&mut self) -> &mut T[src]impl<T> From<T> for T[src]impl<T, U> Into<U> for T where
U: From<T>, [src]impl<T> ToOwned for T where
T: Clone, [src]type Owned = TThe resulting type after obtaining ownership.
-pub fn to_owned(&self) -> T[src]pub fn clone_into(&self, target: &mut T)[src]impl<T> ToString for T where
T: Display + ?Sized, [src]impl<T, U> TryFrom<U> for T where
U: Into<T>, [src]type Error = InfallibleThe type returned in the event of a conversion error.
-pub fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]impl<T, U> TryInto<U> for T where
U: TryFrom<T>, [src]The offset from the local time to UTC.
-fn fix(&self) -> FixedOffset[src]Returns the fixed offset from UTC to the local time stored.
-impl Offset for FixedOffset[src]fn fix(&self) -> FixedOffset[src]impl Offset for Utc[src]fn fix(&self) -> FixedOffset[src]type Offset: Offset[src]An associated offset type.
-This type is used to store the actual offset in date and time types.
-The original TimeZone value can be recovered via TimeZone::from_offset.
fn from_offset(offset: &Self::Offset) -> Self[src]Reconstructs the time zone from the offset.
-fn offset_from_local_date(&self, local: &NaiveDate) -> LocalResult<Self::Offset>[src]Creates the offset(s) for given local NaiveDate if possible.
fn offset_from_local_datetime(
&self,
local: &NaiveDateTime
) -> LocalResult<Self::Offset>[src]Creates the offset(s) for given local NaiveDateTime if possible.
fn offset_from_utc_date(&self, utc: &NaiveDate) -> Self::Offset[src]Creates the offset for given UTC NaiveDate. This cannot fail.
fn offset_from_utc_datetime(&self, utc: &NaiveDateTime) -> Self::Offset[src]Creates the offset for given UTC NaiveDateTime. This cannot fail.
fn ymd(&self, year: i32, month: u32, day: u32) -> Date<Self>[src]Makes a new Date from year, month, day and the current time zone.
-This assumes the proleptic Gregorian calendar, with the year 0 being 1 BCE.
The time zone normally does not affect the date (unless it is between UTC-24 and UTC+24),
-but it will propagate to the DateTime values constructed via this date.
Panics on the out-of-range date, invalid month and/or day.
--use chrono::{Utc, TimeZone}; - -assert_eq!(Utc.ymd(2015, 5, 15).to_string(), "2015-05-15UTC");
fn ymd_opt(&self, year: i32, month: u32, day: u32) -> LocalResult<Date<Self>>[src]Makes a new Date from year, month, day and the current time zone.
-This assumes the proleptic Gregorian calendar, with the year 0 being 1 BCE.
The time zone normally does not affect the date (unless it is between UTC-24 and UTC+24),
-but it will propagate to the DateTime values constructed via this date.
Returns None on the out-of-range date, invalid month and/or day.
-use chrono::{Utc, LocalResult, TimeZone}; - -assert_eq!(Utc.ymd_opt(2015, 5, 15).unwrap().to_string(), "2015-05-15UTC"); -assert_eq!(Utc.ymd_opt(2000, 0, 0), LocalResult::None);
fn yo(&self, year: i32, ordinal: u32) -> Date<Self>[src]Makes a new Date from year, day of year (DOY or "ordinal") and the current time zone.
-This assumes the proleptic Gregorian calendar, with the year 0 being 1 BCE.
The time zone normally does not affect the date (unless it is between UTC-24 and UTC+24),
-but it will propagate to the DateTime values constructed via this date.
Panics on the out-of-range date and/or invalid DOY.
--use chrono::{Utc, TimeZone}; - -assert_eq!(Utc.yo(2015, 135).to_string(), "2015-05-15UTC");
fn yo_opt(&self, year: i32, ordinal: u32) -> LocalResult<Date<Self>>[src]Makes a new Date from year, day of year (DOY or "ordinal") and the current time zone.
-This assumes the proleptic Gregorian calendar, with the year 0 being 1 BCE.
The time zone normally does not affect the date (unless it is between UTC-24 and UTC+24),
-but it will propagate to the DateTime values constructed via this date.
Returns None on the out-of-range date and/or invalid DOY.
fn isoywd(&self, year: i32, week: u32, weekday: Weekday) -> Date<Self>[src]Makes a new Date from ISO week date (year and week number), day of the week (DOW) and
-the current time zone.
-This assumes the proleptic Gregorian calendar, with the year 0 being 1 BCE.
-The resulting Date may have a different year from the input year.
The time zone normally does not affect the date (unless it is between UTC-24 and UTC+24),
-but it will propagate to the DateTime values constructed via this date.
Panics on the out-of-range date and/or invalid week number.
--use chrono::{Utc, Weekday, TimeZone}; - -assert_eq!(Utc.isoywd(2015, 20, Weekday::Fri).to_string(), "2015-05-15UTC");
fn isoywd_opt(
&self,
year: i32,
week: u32,
weekday: Weekday
) -> LocalResult<Date<Self>>[src]Makes a new Date from ISO week date (year and week number), day of the week (DOW) and
-the current time zone.
-This assumes the proleptic Gregorian calendar, with the year 0 being 1 BCE.
-The resulting Date may have a different year from the input year.
The time zone normally does not affect the date (unless it is between UTC-24 and UTC+24),
-but it will propagate to the DateTime values constructed via this date.
Returns None on the out-of-range date and/or invalid week number.
fn timestamp(&self, secs: i64, nsecs: u32) -> DateTime<Self>[src]Makes a new DateTime 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.
Panics on the out-of-range number of seconds and/or invalid nanosecond,
-for a non-panicking version see timestamp_opt.
-use chrono::{Utc, TimeZone}; - -assert_eq!(Utc.timestamp(1431648000, 0).to_string(), "2015-05-15 00:00:00 UTC");
fn timestamp_opt(&self, secs: i64, nsecs: u32) -> LocalResult<DateTime<Self>>[src]Makes a new DateTime 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.
Returns LocalResult::None on out-of-range number of seconds and/or
-invalid nanosecond, otherwise always returns LocalResult::Single.
fn timestamp_millis(&self, millis: i64) -> DateTime<Self>[src]Makes a new DateTime from the number of non-leap milliseconds
-since January 1, 1970 0:00:00 UTC (aka "UNIX timestamp").
Panics on out-of-range number of milliseconds for a non-panicking
-version see timestamp_millis_opt.
-use chrono::{Utc, TimeZone}; - -assert_eq!(Utc.timestamp_millis(1431648000).timestamp(), 1431648);
fn timestamp_millis_opt(&self, millis: i64) -> LocalResult<DateTime<Self>>[src]Makes a new DateTime from the number of non-leap milliseconds
-since January 1, 1970 0:00:00 UTC (aka "UNIX timestamp").
Returns LocalResult::None on out-of-range number of milliseconds
-and/or invalid nanosecond, otherwise always returns
-LocalResult::Single.
-use chrono::{Utc, TimeZone, LocalResult}; -match Utc.timestamp_millis_opt(1431648000) { - LocalResult::Single(dt) => assert_eq!(dt.timestamp(), 1431648), - _ => panic!("Incorrect timestamp_millis"), -};
fn timestamp_nanos(&self, nanos: i64) -> DateTime<Self>[src]Makes a new DateTime from the number of non-leap nanoseconds
-since January 1, 1970 0:00:00 UTC (aka "UNIX timestamp").
Unlike timestamp_millis, this never
-panics.
-use chrono::{Utc, TimeZone}; - -assert_eq!(Utc.timestamp_nanos(1431648000000000).timestamp(), 1431648);
fn datetime_from_str(&self, s: &str, fmt: &str) -> ParseResult<DateTime<Self>>[src]Parses a string with the specified format string and
-returns a DateTime with the current offset.
-See the format::strftime module
-on the supported escape sequences.
If the format does not include offsets, the current offset is assumed; -otherwise the input should have a matching UTC offset.
-See also DateTime::parse_from_str which gives a local DateTime
-with parsed FixedOffset.
fn from_local_date(&self, local: &NaiveDate) -> LocalResult<Date<Self>>[src]Converts the local NaiveDate to the timezone-aware Date if possible.
fn from_local_datetime(
&self,
local: &NaiveDateTime
) -> LocalResult<DateTime<Self>>[src]Converts the local NaiveDateTime to the timezone-aware DateTime if possible.
fn from_utc_date(&self, utc: &NaiveDate) -> Date<Self>[src]Converts the UTC NaiveDate to the local time.
-The UTC is continuous and thus this cannot fail (but can give the duplicate local time).
fn from_utc_datetime(&self, utc: &NaiveDateTime) -> DateTime<Self>[src]Converts the UTC NaiveDateTime to the local time.
-The UTC is continuous and thus this cannot fail (but can give the duplicate local time).
impl TimeZone for FixedOffset[src]type Offset = FixedOffsetfn from_offset(offset: &FixedOffset) -> FixedOffset[src]fn offset_from_local_date(&self, _local: &NaiveDate) -> LocalResult<FixedOffset>[src]fn offset_from_local_datetime(
&self,
_local: &NaiveDateTime
) -> LocalResult<FixedOffset>[src]fn offset_from_utc_date(&self, _utc: &NaiveDate) -> FixedOffset[src]fn offset_from_utc_datetime(&self, _utc: &NaiveDateTime) -> FixedOffset[src]impl TimeZone for Local[src]type Offset = FixedOffsetfn from_offset(_offset: &FixedOffset) -> Local[src]fn offset_from_local_date(&self, local: &NaiveDate) -> LocalResult<FixedOffset>[src]fn offset_from_local_datetime(
&self,
local: &NaiveDateTime
) -> LocalResult<FixedOffset>[src]fn offset_from_utc_date(&self, utc: &NaiveDate) -> FixedOffset[src]fn offset_from_utc_datetime(&self, utc: &NaiveDateTime) -> FixedOffset[src]fn from_local_date(&self, local: &NaiveDate) -> LocalResult<Date<Local>>[src]fn from_local_datetime(
&self,
local: &NaiveDateTime
) -> LocalResult<DateTime<Local>>[src]fn from_utc_date(&self, utc: &NaiveDate) -> Date<Local>[src]fn from_utc_datetime(&self, utc: &NaiveDateTime) -> DateTime<Local>[src]impl TimeZone for Utc[src]type Offset = Utcfn from_offset(_state: &Utc) -> Utc[src]fn offset_from_local_date(&self, _local: &NaiveDate) -> LocalResult<Utc>[src]fn offset_from_local_datetime(&self, _local: &NaiveDateTime) -> LocalResult<Utc>[src]fn offset_from_utc_date(&self, _utc: &NaiveDate) -> Utc[src]fn offset_from_utc_datetime(&self, _utc: &NaiveDateTime) -> Utc[src]Redirecting to ../../../chrono/offset/struct.Utc.html...
- - - \ No newline at end of file diff --git a/docs/chrono/prelude/index.html b/docs/chrono/prelude/index.html deleted file mode 100644 index 49e036a9..00000000 --- a/docs/chrono/prelude/index.html +++ /dev/null @@ -1,6 +0,0 @@ -A convenience module appropriate for glob imports (use chrono::prelude::*;).
pub use Date; |
pub use Local; |
pub use SubsecRound; |
pub use DateTime; |
pub use SecondsFormat; |
pub use Datelike; |
pub use Month; |
pub use Timelike; |
pub use Weekday; |
pub use FixedOffset; |
pub use Utc; |
pub use NaiveDate; |
pub use NaiveDateTime; |
pub use NaiveTime; |
pub use Offset; |
pub use TimeZone; |
Redirecting to ../../chrono/enum.RoundingError.html...
- - - \ No newline at end of file diff --git a/docs/chrono/round/trait.DurationRound.html b/docs/chrono/round/trait.DurationRound.html deleted file mode 100644 index 43581e44..00000000 --- a/docs/chrono/round/trait.DurationRound.html +++ /dev/null @@ -1,10 +0,0 @@ - - - - - - -Redirecting to ../../chrono/trait.DurationRound.html...
- - - \ No newline at end of file diff --git a/docs/chrono/round/trait.SubsecRound.html b/docs/chrono/round/trait.SubsecRound.html deleted file mode 100644 index 643966d0..00000000 --- a/docs/chrono/round/trait.SubsecRound.html +++ /dev/null @@ -1,10 +0,0 @@ - - - - - - -Redirecting to ../../chrono/trait.SubsecRound.html...
- - - \ No newline at end of file diff --git a/docs/chrono/sidebar-items.js b/docs/chrono/sidebar-items.js deleted file mode 100644 index db0c5512..00000000 --- a/docs/chrono/sidebar-items.js +++ /dev/null @@ -1 +0,0 @@ -initSidebarItems({"constant":[["MAX_DATE","The maximum possible `Date`."],["MAX_DATETIME","The maximum possible `DateTimeISO 8601 calendar date with time zone.
-This type should be considered ambiguous at best,
-due to the inherent lack of precision required for the time zone resolution.
-For serialization and deserialization uses, it is best to use NaiveDate instead.
-There are some guarantees on the usage of Date<Tz>:
If properly constructed via TimeZone::ymd and others without an error,
-the corresponding local date should exist for at least a moment.
-(It may still have a gap from the offset changes.)
The TimeZone is free to assign any Offset to the local date,
-as long as that offset did occur in given day.
-For example, if 2015-03-08T01:59-08:00 is followed by 2015-03-08T03:00-07:00,
-it may produce either 2015-03-08-08:00 or 2015-03-08-07:00
-but not 2015-03-08+00:00 and others.
Once constructed as a full DateTime,
-DateTime::date and other associated methods should return those for the original Date.
-For example, if dt = tz.ymd(y,m,d).hms(h,n,s) were valid, dt.date() == tz.ymd(y,m,d).
The date is timezone-agnostic up to one day (i.e. practically always),
-so the local date and UTC date should be equal for most cases
-even though the raw calculation between NaiveDate and Duration may not.
impl<Tz: TimeZone> Date<Tz>[src]pub fn from_utc(date: NaiveDate, offset: Tz::Offset) -> Date<Tz>[src]Makes a new Date with given UTC date and offset.
-The local date should be constructed via the TimeZone trait.
pub fn and_time(&self, time: NaiveTime) -> Option<DateTime<Tz>>[src]Makes a new DateTime from the current date and given NaiveTime.
-The offset in the current date is preserved.
Panics on invalid datetime.
-pub fn and_hms(&self, hour: u32, min: u32, sec: u32) -> DateTime<Tz>[src]Makes a new DateTime from the current date, hour, minute and second.
-The offset in the current date is preserved.
Panics on invalid hour, minute and/or second.
-pub fn and_hms_opt(&self, hour: u32, min: u32, sec: u32) -> Option<DateTime<Tz>>[src]Makes a new DateTime from the current date, hour, minute and second.
-The offset in the current date is preserved.
Returns None on invalid hour, minute and/or second.
pub fn and_hms_milli(
&self,
hour: u32,
min: u32,
sec: u32,
milli: u32
) -> DateTime<Tz>[src]Makes a new DateTime from the current date, hour, minute, second and millisecond.
-The millisecond part can exceed 1,000 in order to represent the leap second.
-The offset in the current date is preserved.
Panics on invalid hour, minute, second and/or millisecond.
-pub fn and_hms_milli_opt(
&self,
hour: u32,
min: u32,
sec: u32,
milli: u32
) -> Option<DateTime<Tz>>[src]Makes a new DateTime from the current date, hour, minute, second and millisecond.
-The millisecond part can exceed 1,000 in order to represent the leap second.
-The offset in the current date is preserved.
Returns None on invalid hour, minute, second and/or millisecond.
pub fn and_hms_micro(
&self,
hour: u32,
min: u32,
sec: u32,
micro: u32
) -> DateTime<Tz>[src]Makes a new DateTime from the current date, hour, minute, second and microsecond.
-The microsecond part can exceed 1,000,000 in order to represent the leap second.
-The offset in the current date is preserved.
Panics on invalid hour, minute, second and/or microsecond.
-pub fn and_hms_micro_opt(
&self,
hour: u32,
min: u32,
sec: u32,
micro: u32
) -> Option<DateTime<Tz>>[src]Makes a new DateTime from the current date, hour, minute, second and microsecond.
-The microsecond part can exceed 1,000,000 in order to represent the leap second.
-The offset in the current date is preserved.
Returns None on invalid hour, minute, second and/or microsecond.
pub fn and_hms_nano(
&self,
hour: u32,
min: u32,
sec: u32,
nano: u32
) -> DateTime<Tz>[src]Makes a new DateTime from the current date, hour, minute, second and nanosecond.
-The nanosecond part can exceed 1,000,000,000 in order to represent the leap second.
-The offset in the current date is preserved.
Panics on invalid hour, minute, second and/or nanosecond.
-pub fn and_hms_nano_opt(
&self,
hour: u32,
min: u32,
sec: u32,
nano: u32
) -> Option<DateTime<Tz>>[src]Makes a new DateTime from the current date, hour, minute, second and nanosecond.
-The nanosecond part can exceed 1,000,000,000 in order to represent the leap second.
-The offset in the current date is preserved.
Returns None on invalid hour, minute, second and/or nanosecond.
pub fn succ(&self) -> Date<Tz>[src]Makes a new Date for the next date.
Panics when self is the last representable date.
pub fn succ_opt(&self) -> Option<Date<Tz>>[src]Makes a new Date for the next date.
Returns None when self is the last representable date.
pub fn pred(&self) -> Date<Tz>[src]Makes a new Date for the prior date.
Panics when self is the first representable date.
pub fn pred_opt(&self) -> Option<Date<Tz>>[src]Makes a new Date for the prior date.
Returns None when self is the first representable date.
pub fn offset(&self) -> &Tz::Offset[src]Retrieves an associated offset from UTC.
-pub fn timezone(&self) -> Tz[src]Retrieves an associated time zone.
-pub fn with_timezone<Tz2: TimeZone>(&self, tz: &Tz2) -> Date<Tz2>[src]Changes the associated time zone.
-This does not change the actual Date (but will change the string representation).
pub fn checked_add_signed(self, rhs: OldDuration) -> Option<Date<Tz>>[src]Adds given Duration to the current date.
Returns None when it will result in overflow.
pub fn checked_sub_signed(self, rhs: OldDuration) -> Option<Date<Tz>>[src]Subtracts given Duration from the current date.
Returns None when it will result in overflow.
pub fn signed_duration_since<Tz2: TimeZone>(self, rhs: Date<Tz2>) -> OldDuration[src]Subtracts another Date from the current date.
-Returns a Duration of integral numbers.
This does not overflow or underflow at all,
-as all possible output fits in the range of Duration.
pub fn naive_utc(&self) -> NaiveDate[src]Returns a view to the naive UTC date.
-pub fn naive_local(&self) -> NaiveDate[src]Returns a view to the naive local date.
-This is technically the same as naive_utc
-because the offset is restricted to never exceed one day,
-but provided for the consistency.
impl<Tz: TimeZone> Date<Tz> where
Tz::Offset: Display, [src]pub fn format_with_items<'a, I, B>(&self, items: I) -> DelayedFormat<I> where
I: Iterator<Item = B> + Clone,
B: Borrow<Item<'a>>, [src]Formats the date with the specified formatting items.
-pub fn format<'a>(&self, fmt: &'a str) -> DelayedFormat<StrftimeItems<'a>>[src]Formats the date with the specified format string.
-See the format::strftime module
-on the supported escape sequences.
impl<Tz: TimeZone> Add<Duration> for Date<Tz>[src]type Output = Date<Tz>The resulting type after applying the + operator.
fn add(self, rhs: OldDuration) -> Date<Tz>[src]impl<Tz: Clone + TimeZone> Clone for Date<Tz> where
Tz::Offset: Clone, [src]impl<Tz: TimeZone> Copy for Date<Tz> where
<Tz as TimeZone>::Offset: Copy, [src]impl<Tz: TimeZone> Datelike for Date<Tz>[src]fn year(&self) -> i32[src]fn month(&self) -> u32[src]fn month0(&self) -> u32[src]fn day(&self) -> u32[src]fn day0(&self) -> u32[src]fn ordinal(&self) -> u32[src]fn ordinal0(&self) -> u32[src]fn weekday(&self) -> Weekday[src]fn iso_week(&self) -> IsoWeek[src]fn with_year(&self, year: i32) -> Option<Date<Tz>>[src]fn with_month(&self, month: u32) -> Option<Date<Tz>>[src]fn with_month0(&self, month0: u32) -> Option<Date<Tz>>[src]fn with_day(&self, day: u32) -> Option<Date<Tz>>[src]fn with_day0(&self, day0: u32) -> Option<Date<Tz>>[src]fn with_ordinal(&self, ordinal: u32) -> Option<Date<Tz>>[src]fn with_ordinal0(&self, ordinal0: u32) -> Option<Date<Tz>>[src]fn year_ce(&self) -> (bool, u32)[src]fn num_days_from_ce(&self) -> i32[src]impl<Tz: TimeZone> Debug for Date<Tz>[src]impl<Tz: TimeZone> Display for Date<Tz> where
Tz::Offset: Display, [src]impl<Tz: TimeZone> Eq for Date<Tz>[src]impl<Tz: TimeZone> Hash for Date<Tz>[src]fn hash<H: Hasher>(&self, state: &mut H)[src]pub fn hash_slice<H>(data: &[Self], state: &mut H) where
H: Hasher, 1.3.0[src]impl<Tz: TimeZone> Ord for Date<Tz>[src]fn cmp(&self, other: &Date<Tz>) -> Ordering[src]#[must_use]pub fn max(self, other: Self) -> Self1.21.0[src]#[must_use]pub fn min(self, other: Self) -> Self1.21.0[src]#[must_use]pub fn clamp(self, min: Self, max: Self) -> Self1.50.0[src]impl<Tz: TimeZone, Tz2: TimeZone> PartialEq<Date<Tz2>> for Date<Tz>[src]fn eq(&self, other: &Date<Tz2>) -> bool[src]#[must_use]pub fn ne(&self, other: &Rhs) -> bool1.0.0[src]impl<Tz: TimeZone> PartialOrd<Date<Tz>> for Date<Tz>[src]fn partial_cmp(&self, other: &Date<Tz>) -> Option<Ordering>[src]#[must_use]pub fn lt(&self, other: &Rhs) -> bool1.0.0[src]#[must_use]pub fn le(&self, other: &Rhs) -> bool1.0.0[src]#[must_use]pub fn gt(&self, other: &Rhs) -> bool1.0.0[src]#[must_use]pub fn ge(&self, other: &Rhs) -> bool1.0.0[src]impl<Tz: TimeZone> Send for Date<Tz> where
<Tz as TimeZone>::Offset: Send, [src]impl<Tz: TimeZone> Sub<Date<Tz>> for Date<Tz>[src]type Output = OldDurationThe resulting type after applying the - operator.
fn sub(self, rhs: Date<Tz>) -> OldDuration[src]impl<Tz: TimeZone> Sub<Duration> for Date<Tz>[src]impl<Tz> RefUnwindSafe for Date<Tz> where
<Tz as TimeZone>::Offset: RefUnwindSafe, [src]impl<Tz> Sync for Date<Tz> where
<Tz as TimeZone>::Offset: Sync, [src]impl<Tz> Unpin for Date<Tz> where
<Tz as TimeZone>::Offset: Unpin, [src]impl<Tz> UnwindSafe for Date<Tz> where
<Tz as TimeZone>::Offset: UnwindSafe, [src]impl<T> Any for T where
T: 'static + ?Sized, [src]impl<T> Borrow<T> for T where
T: ?Sized, [src]impl<T> BorrowMut<T> for T where
T: ?Sized, [src]pub fn borrow_mut(&mut self) -> &mut T[src]impl<T> From<T> for T[src]impl<T, U> Into<U> for T where
U: From<T>, [src]impl<T> ToOwned for T where
T: Clone, [src]type Owned = TThe resulting type after obtaining ownership.
-pub fn to_owned(&self) -> T[src]pub fn clone_into(&self, target: &mut T)[src]impl<T> ToString for T where
T: Display + ?Sized, [src]impl<T, U> TryFrom<U> for T where
U: Into<T>, [src]type Error = InfallibleThe type returned in the event of a conversion error.
-pub fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]impl<T, U> TryInto<U> for T where
U: TryFrom<T>, [src]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.
impl<Tz: TimeZone> DateTime<Tz>[src]pub fn from_utc(datetime: NaiveDateTime, offset: Tz::Offset) -> DateTime<Tz>[src]Makes a new DateTime with given UTC datetime and offset.
-The local datetime should be constructed via the TimeZone trait.
-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);
pub fn date(&self) -> Date<Tz>[src]Retrieves a date component.
-pub fn time(&self) -> NaiveTime[src]Retrieves a time component.
-Unlike date, this is not associated to the time zone.
pub fn timestamp(&self) -> i64[src]Returns the number of non-leap seconds since January 1, 1970 0:00:00 UTC -(aka "UNIX timestamp").
-pub fn timestamp_millis(&self) -> i64[src]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.)
--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);
pub fn timestamp_nanos(&self) -> i64[src]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.)
--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);
pub fn timestamp_subsec_millis(&self) -> u32[src]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
-pub fn timestamp_subsec_micros(&self) -> u32[src]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
-pub fn timestamp_subsec_nanos(&self) -> u32[src]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
-pub fn offset(&self) -> &Tz::Offset[src]Retrieves an associated offset from UTC.
-pub fn timezone(&self) -> Tz[src]Retrieves an associated time zone.
-pub fn with_timezone<Tz2: TimeZone>(&self, tz: &Tz2) -> DateTime<Tz2>[src]Changes the associated time zone.
-This does not change the actual DateTime (but will change the string representation).
pub fn checked_add_signed(self, rhs: OldDuration) -> Option<DateTime<Tz>>[src]Adds given Duration to the current date and time.
Returns None when it will result in overflow.
pub fn checked_sub_signed(self, rhs: OldDuration) -> Option<DateTime<Tz>>[src]Subtracts given Duration from the current date and time.
Returns None when it will result in overflow.
pub fn signed_duration_since<Tz2: TimeZone>(
self,
rhs: DateTime<Tz2>
) -> OldDuration[src]Subtracts another DateTime from the current date and time.
-This does not overflow or underflow at all.
pub fn naive_utc(&self) -> NaiveDateTime[src]Returns a view to the naive UTC datetime.
-pub fn naive_local(&self) -> NaiveDateTime[src]Returns a view to the naive local datetime.
-impl DateTime<FixedOffset>[src]pub fn parse_from_rfc2822(s: &str) -> ParseResult<DateTime<FixedOffset>>[src]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 specifices 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) -);
pub fn parse_from_rfc3339(s: &str) -> ParseResult<DateTime<FixedOffset>>[src]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.
pub fn parse_from_str(s: &str, fmt: &str) -> ParseResult<DateTime<FixedOffset>>[src]Parses a string with the specified format string and
-returns a new DateTime with a parsed FixedOffset.
-See the format::strftime module
-on the supported escape sequences.
See also Offset::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.
-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)));
impl<Tz: TimeZone> DateTime<Tz> where
Tz::Offset: Display, [src]pub fn to_rfc2822(&self) -> String[src]Returns an RFC 2822 date and time string such as Tue, 1 Jul 2003 10:52:37 +0200.
pub fn to_rfc3339(&self) -> String[src]Returns an RFC 3339 and ISO 8601 date and time string such as 1996-12-19T16:39:57-08:00.
pub fn to_rfc3339_opts(&self, secform: SecondsFormat, use_z: bool) -> String[src]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.
-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");
pub fn format_with_items<'a, I, B>(&self, items: I) -> DelayedFormat<I> where
I: Iterator<Item = B> + Clone,
B: Borrow<Item<'a>>, [src]Formats the combined date and time with the specified formatting items.
-pub fn format<'a>(&self, fmt: &'a str) -> DelayedFormat<StrftimeItems<'a>>[src]Formats the combined date and time with the specified format string.
-See the format::strftime module
-on the supported escape sequences.
impl<Tz: TimeZone> Add<Duration> for DateTime<Tz>[src]type Output = DateTime<Tz>The resulting type after applying the + operator.
fn add(self, rhs: OldDuration) -> DateTime<Tz>[src]impl<Tz: TimeZone> Add<FixedOffset> for DateTime<Tz>[src]type Output = DateTime<Tz>The resulting type after applying the + operator.
fn add(self, rhs: FixedOffset) -> DateTime<Tz>[src]impl<Tz: Clone + TimeZone> Clone for DateTime<Tz> where
Tz::Offset: Clone, [src]impl<Tz: TimeZone> Copy for DateTime<Tz> where
<Tz as TimeZone>::Offset: Copy, [src]impl<Tz: TimeZone> Datelike for DateTime<Tz>[src]fn year(&self) -> i32[src]fn month(&self) -> u32[src]fn month0(&self) -> u32[src]fn day(&self) -> u32[src]fn day0(&self) -> u32[src]fn ordinal(&self) -> u32[src]fn ordinal0(&self) -> u32[src]fn weekday(&self) -> Weekday[src]fn iso_week(&self) -> IsoWeek[src]fn with_year(&self, year: i32) -> Option<DateTime<Tz>>[src]fn with_month(&self, month: u32) -> Option<DateTime<Tz>>[src]fn with_month0(&self, month0: u32) -> Option<DateTime<Tz>>[src]fn with_day(&self, day: u32) -> Option<DateTime<Tz>>[src]fn with_day0(&self, day0: u32) -> Option<DateTime<Tz>>[src]fn with_ordinal(&self, ordinal: u32) -> Option<DateTime<Tz>>[src]fn with_ordinal0(&self, ordinal0: u32) -> Option<DateTime<Tz>>[src]fn year_ce(&self) -> (bool, u32)[src]fn num_days_from_ce(&self) -> i32[src]impl<Tz: TimeZone> Debug for DateTime<Tz>[src]impl<Tz: TimeZone> Display for DateTime<Tz> where
Tz::Offset: Display, [src]impl<Tz: TimeZone> DurationRound for DateTime<Tz>[src]type Err = RoundingErrorError that can occur in rounding or truncating
-fn duration_round(self, duration: Duration) -> Result<Self, Self::Err>[src]fn duration_trunc(self, duration: Duration) -> Result<Self, Self::Err>[src]impl<Tz: TimeZone> Eq for DateTime<Tz>[src]impl From<DateTime<FixedOffset>> for DateTime<Utc>[src]Convert a DateTime<FixedOffset> instance into a DateTime<Utc> instance.
fn from(src: DateTime<FixedOffset>) -> Self[src]Convert this DateTime<FixedOffset> instance into a DateTime<Utc> instance.
Conversion is performed via DateTime::with_timezone, accounting for the timezone
-difference.
impl From<DateTime<FixedOffset>> for DateTime<Local>[src]Convert a DateTime<FixedOffset> instance into a DateTime<Local> instance.
fn from(src: DateTime<FixedOffset>) -> Self[src]Convert this DateTime<FixedOffset> instance into a DateTime<Local> instance.
Conversion is performed via DateTime::with_timezone. Returns the equivalent value in local
-time.
impl From<DateTime<Local>> for DateTime<Utc>[src]Convert a DateTime<Local> instance into a DateTime<Utc> instance.
fn from(src: DateTime<Local>) -> Self[src]Convert this DateTime<Local> instance into a DateTime<Utc> instance.
Conversion is performed via DateTime::with_timezone, accounting for the difference in
-timezones.
impl From<DateTime<Local>> for DateTime<FixedOffset>[src]Convert a DateTime<Local> instance into a DateTime<FixedOffset> instance.
fn from(src: DateTime<Local>) -> Self[src]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.
impl<Tz: TimeZone> From<DateTime<Tz>> for SystemTime[src]fn from(dt: DateTime<Tz>) -> SystemTime[src]impl From<DateTime<Utc>> for DateTime<FixedOffset>[src]Convert a DateTime<Utc> instance into a DateTime<FixedOffset> instance.
fn from(src: DateTime<Utc>) -> Self[src]Convert this DateTime<Utc> instance into a DateTime<FixedOffset> instance.
Conversion is done via DateTime::with_timezone. Note that the converted value returned by
-this will be created with a fixed timezone offset of 0.
impl From<DateTime<Utc>> for DateTime<Local>[src]Convert a DateTime<Utc> instance into a DateTime<Local> instance.
fn from(src: DateTime<Utc>) -> Self[src]Convert this DateTime<Utc> instance into a DateTime<Local> instance.
Conversion is performed via DateTime::with_timezone, accounting for the difference in timezones.
impl From<SystemTime> for DateTime<Utc>[src]fn from(t: SystemTime) -> DateTime<Utc>[src]impl From<SystemTime> for DateTime<Local>[src]fn from(t: SystemTime) -> DateTime<Local>[src]impl FromStr for DateTime<Utc>[src]type Err = ParseErrorThe associated error which can be returned from parsing.
-fn from_str(s: &str) -> ParseResult<DateTime<Utc>>[src]impl FromStr for DateTime<Local>[src]type Err = ParseErrorThe associated error which can be returned from parsing.
-fn from_str(s: &str) -> ParseResult<DateTime<Local>>[src]impl FromStr for DateTime<FixedOffset>[src]type Err = ParseErrorThe associated error which can be returned from parsing.
-fn from_str(s: &str) -> ParseResult<DateTime<FixedOffset>>[src]impl<Tz: TimeZone> Hash for DateTime<Tz>[src]fn hash<H: Hasher>(&self, state: &mut H)[src]pub fn hash_slice<H>(data: &[Self], state: &mut H) where
H: Hasher, 1.3.0[src]impl<Tz: TimeZone> Ord for DateTime<Tz>[src]fn cmp(&self, other: &DateTime<Tz>) -> Ordering[src]#[must_use]pub fn max(self, other: Self) -> Self1.21.0[src]#[must_use]pub fn min(self, other: Self) -> Self1.21.0[src]#[must_use]pub fn clamp(self, min: Self, max: Self) -> Self1.50.0[src]impl<Tz: TimeZone, Tz2: TimeZone> PartialEq<DateTime<Tz2>> for DateTime<Tz>[src]fn eq(&self, other: &DateTime<Tz2>) -> bool[src]#[must_use]pub fn ne(&self, other: &Rhs) -> bool1.0.0[src]impl<Tz: TimeZone, Tz2: TimeZone> PartialOrd<DateTime<Tz2>> for DateTime<Tz>[src]fn partial_cmp(&self, other: &DateTime<Tz2>) -> Option<Ordering>[src]Compare two DateTimes based on their true time, ignoring time zones
--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);
#[must_use]pub fn lt(&self, other: &Rhs) -> bool1.0.0[src]#[must_use]pub fn le(&self, other: &Rhs) -> bool1.0.0[src]#[must_use]pub fn gt(&self, other: &Rhs) -> bool1.0.0[src]#[must_use]pub fn ge(&self, other: &Rhs) -> bool1.0.0[src]impl<Tz: TimeZone> Send for DateTime<Tz> where
<Tz as TimeZone>::Offset: Send, [src]impl<Tz: TimeZone> Sub<DateTime<Tz>> for DateTime<Tz>[src]type Output = OldDurationThe resulting type after applying the - operator.
fn sub(self, rhs: DateTime<Tz>) -> OldDuration[src]impl<Tz: TimeZone> Sub<Duration> for DateTime<Tz>[src]type Output = DateTime<Tz>The resulting type after applying the - operator.
fn sub(self, rhs: OldDuration) -> DateTime<Tz>[src]impl<Tz: TimeZone> Sub<FixedOffset> for DateTime<Tz>[src]type Output = DateTime<Tz>The resulting type after applying the - operator.
fn sub(self, rhs: FixedOffset) -> DateTime<Tz>[src]impl<Tz: TimeZone> Timelike for DateTime<Tz>[src]fn hour(&self) -> u32[src]fn minute(&self) -> u32[src]fn second(&self) -> u32[src]fn nanosecond(&self) -> u32[src]fn with_hour(&self, hour: u32) -> Option<DateTime<Tz>>[src]fn with_minute(&self, min: u32) -> Option<DateTime<Tz>>[src]fn with_second(&self, sec: u32) -> Option<DateTime<Tz>>[src]fn with_nanosecond(&self, nano: u32) -> Option<DateTime<Tz>>[src]fn hour12(&self) -> (bool, u32)[src]fn num_seconds_from_midnight(&self) -> u32[src]impl<Tz> RefUnwindSafe for DateTime<Tz> where
<Tz as TimeZone>::Offset: RefUnwindSafe, [src]impl<Tz> Sync for DateTime<Tz> where
<Tz as TimeZone>::Offset: Sync, [src]impl<Tz> Unpin for DateTime<Tz> where
<Tz as TimeZone>::Offset: Unpin, [src]impl<Tz> UnwindSafe for DateTime<Tz> where
<Tz as TimeZone>::Offset: UnwindSafe, [src]impl<T> Any for T where
T: 'static + ?Sized, [src]impl<T> Borrow<T> for T where
T: ?Sized, [src]impl<T> BorrowMut<T> for T where
T: ?Sized, [src]pub fn borrow_mut(&mut self) -> &mut T[src]impl<T> From<T> for T[src]impl<T, U> Into<U> for T where
U: From<T>, [src]impl<T> ToOwned for T where
T: Clone, [src]type Owned = TThe resulting type after obtaining ownership.
-pub fn to_owned(&self) -> T[src]pub fn clone_into(&self, target: &mut T)[src]impl<T> ToString for T where
T: Display + ?Sized, [src]impl<T, U> TryFrom<U> for T where
U: Into<T>, [src]type Error = InfallibleThe type returned in the event of a conversion error.
-pub fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]impl<T, U> TryInto<U> for T where
U: TryFrom<T>, [src]ISO 8601 time duration with nanosecond precision. -This also allows for the negative duration; see individual methods for details.
-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]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.
-impl Add<Duration> for Duration[src]type Output = DurationThe resulting type after applying the + operator.
pub fn add(self, rhs: Duration) -> Duration[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.
-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));
type Output = NaiveDateThe resulting type after applying the + operator.
fn add(self, rhs: OldDuration) -> NaiveDate[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.
-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 = NaiveDateTimeThe resulting type after applying the + operator.
fn add(self, rhs: OldDuration) -> NaiveDateTime[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.
-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));
type Output = NaiveTimeThe resulting type after applying the + operator.
fn add(self, rhs: OldDuration) -> NaiveTime[src]impl<Tz: TimeZone> Add<Duration> for Date<Tz>[src]type Output = Date<Tz>The resulting type after applying the + operator.
fn add(self, rhs: OldDuration) -> Date<Tz>[src]impl<Tz: TimeZone> Add<Duration> for DateTime<Tz>[src]type Output = DateTime<Tz>The resulting type after applying the + operator.
fn add(self, rhs: OldDuration) -> DateTime<Tz>[src]impl AddAssign<Duration> for NaiveDate[src]fn add_assign(&mut self, rhs: OldDuration)[src]impl AddAssign<Duration> for NaiveDateTime[src]fn add_assign(&mut self, rhs: OldDuration)[src]impl AddAssign<Duration> for NaiveTime[src]fn add_assign(&mut self, rhs: OldDuration)[src]impl Clone for Duration[src]impl Copy for Duration[src]impl Debug for Duration[src]impl Display for Duration[src]impl Div<i32> for Duration[src]type Output = DurationThe resulting type after applying the / operator.
pub fn div(self, rhs: i32) -> Duration[src]impl Eq for Duration[src]impl Hash for Duration[src]pub fn hash<__H>(&self, state: &mut __H) where
__H: Hasher, [src]pub fn hash_slice<H>(data: &[Self], state: &mut H) where
H: Hasher, 1.3.0[src]impl Mul<i32> for Duration[src]type Output = DurationThe resulting type after applying the * operator.
pub fn mul(self, rhs: i32) -> Duration[src]impl Neg for Duration[src]type Output = DurationThe resulting type after applying the - operator.
pub fn neg(self) -> Duration[src]impl Ord for Duration[src]pub fn cmp(&self, other: &Duration) -> Ordering[src]#[must_use]pub fn max(self, other: Self) -> Self1.21.0[src]#[must_use]pub fn min(self, other: Self) -> Self1.21.0[src]#[must_use]pub fn clamp(self, min: Self, max: Self) -> Self1.50.0[src]impl PartialEq<Duration> for Duration[src]impl PartialOrd<Duration> for Duration[src]pub fn partial_cmp(&self, other: &Duration) -> Option<Ordering>[src]pub fn lt(&self, other: &Duration) -> bool[src]pub fn le(&self, other: &Duration) -> bool[src]pub fn gt(&self, other: &Duration) -> bool[src]pub fn ge(&self, other: &Duration) -> bool[src]impl StructuralEq for Duration[src]impl StructuralPartialEq for Duration[src]impl Sub<Duration> for Duration[src]type Output = DurationThe resulting type after applying the - operator.
pub fn sub(self, rhs: Duration) -> Duration[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.
-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));
type Output = NaiveDateThe resulting type after applying the - operator.
fn sub(self, rhs: OldDuration) -> NaiveDate[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.
-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 = NaiveDateTimeThe resulting type after applying the - operator.
fn sub(self, rhs: OldDuration) -> NaiveDateTime[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.
-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));
type Output = NaiveTimeThe resulting type after applying the - operator.
fn sub(self, rhs: OldDuration) -> NaiveTime[src]impl<Tz: TimeZone> Sub<Duration> for Date<Tz>[src]type Output = Date<Tz>The resulting type after applying the - operator.
fn sub(self, rhs: OldDuration) -> Date<Tz>[src]impl<Tz: TimeZone> Sub<Duration> for DateTime<Tz>[src]type Output = DateTime<Tz>The resulting type after applying the - operator.
fn sub(self, rhs: OldDuration) -> DateTime<Tz>[src]impl SubAssign<Duration> for NaiveDate[src]fn sub_assign(&mut self, rhs: OldDuration)[src]impl SubAssign<Duration> for NaiveDateTime[src]fn sub_assign(&mut self, rhs: OldDuration)[src]impl SubAssign<Duration> for NaiveTime[src]fn sub_assign(&mut self, rhs: OldDuration)[src]impl RefUnwindSafe for Duration[src]impl Send for Duration[src]impl Sync for Duration[src]impl Unpin for Duration[src]impl UnwindSafe for Duration[src]impl<T> Any for T where
T: 'static + ?Sized, [src]impl<T> Borrow<T> for T where
T: ?Sized, [src]impl<T> BorrowMut<T> for T where
T: ?Sized, [src]pub fn borrow_mut(&mut self) -> &mut T[src]impl<T> From<T> for T[src]impl<T, U> Into<U> for T where
U: From<T>, [src]impl<T> ToOwned for T where
T: Clone, [src]type Owned = TThe resulting type after obtaining ownership.
-pub fn to_owned(&self) -> T[src]pub fn clone_into(&self, target: &mut T)[src]impl<T> ToString for T where
T: Display + ?Sized, [src]impl<T, U> TryFrom<U> for T where
U: Into<T>, [src]type Error = InfallibleThe type returned in the event of a conversion error.
-pub fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]impl<T, U> TryInto<U> for T where
U: TryFrom<T>, [src]An error resulting from reading <Month> value with FromStr.
impl Clone for ParseMonthError[src]fn clone(&self) -> ParseMonthError[src]pub fn clone_from(&mut self, source: &Self)1.0.0[src]impl Debug for ParseMonthError[src]impl PartialEq<ParseMonthError> for ParseMonthError[src]fn eq(&self, other: &ParseMonthError) -> bool[src]fn ne(&self, other: &ParseMonthError) -> bool[src]impl StructuralPartialEq for ParseMonthError[src]impl RefUnwindSafe for ParseMonthError[src]impl Send for ParseMonthError[src]impl Sync for ParseMonthError[src]impl Unpin for ParseMonthError[src]impl UnwindSafe for ParseMonthError[src]impl<T> Any for T where
T: 'static + ?Sized, [src]impl<T> Borrow<T> for T where
T: ?Sized, [src]impl<T> BorrowMut<T> for T where
T: ?Sized, [src]pub fn borrow_mut(&mut self) -> &mut T[src]impl<T> From<T> for T[src]impl<T, U> Into<U> for T where
U: From<T>, [src]impl<T> ToOwned for T where
T: Clone, [src]type Owned = TThe resulting type after obtaining ownership.
-pub fn to_owned(&self) -> T[src]pub fn clone_into(&self, target: &mut T)[src]impl<T, U> TryFrom<U> for T where
U: Into<T>, [src]type Error = InfallibleThe type returned in the event of a conversion error.
-pub fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]impl<T, U> TryInto<U> for T where
U: TryFrom<T>, [src]An error resulting from reading Weekday value with FromStr.
impl Clone for ParseWeekdayError[src]fn clone(&self) -> ParseWeekdayError[src]pub fn clone_from(&mut self, source: &Self)1.0.0[src]impl Debug for ParseWeekdayError[src]impl PartialEq<ParseWeekdayError> for ParseWeekdayError[src]fn eq(&self, other: &ParseWeekdayError) -> bool[src]fn ne(&self, other: &ParseWeekdayError) -> bool[src]impl StructuralPartialEq for ParseWeekdayError[src]impl RefUnwindSafe for ParseWeekdayError[src]impl Send for ParseWeekdayError[src]impl Sync for ParseWeekdayError[src]impl Unpin for ParseWeekdayError[src]impl UnwindSafe for ParseWeekdayError[src]impl<T> Any for T where
T: 'static + ?Sized, [src]impl<T> Borrow<T> for T where
T: ?Sized, [src]impl<T> BorrowMut<T> for T where
T: ?Sized, [src]pub fn borrow_mut(&mut self) -> &mut T[src]impl<T> From<T> for T[src]impl<T, U> Into<U> for T where
U: From<T>, [src]impl<T> ToOwned for T where
T: Clone, [src]type Owned = TThe resulting type after obtaining ownership.
-pub fn to_owned(&self) -> T[src]pub fn clone_into(&self, target: &mut T)[src]impl<T, U> TryFrom<U> for T where
U: Into<T>, [src]type Error = InfallibleThe type returned in the event of a conversion error.
-pub fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]impl<T, U> TryInto<U> for T where
U: TryFrom<T>, [src]The common set of methods for date component.
-fn year(&self) -> i32[src]Returns the year number in the calendar date.
-fn month(&self) -> u32[src]Returns the month number starting from 1.
-The return value ranges from 1 to 12.
-fn month0(&self) -> u32[src]Returns the month number starting from 0.
-The return value ranges from 0 to 11.
-fn day(&self) -> u32[src]Returns the day of month starting from 1.
-The return value ranges from 1 to 31. (The last day of month differs by months.)
-fn day0(&self) -> u32[src]Returns the day of month starting from 0.
-The return value ranges from 0 to 30. (The last day of month differs by months.)
-fn ordinal(&self) -> u32[src]Returns the day of year starting from 1.
-The return value ranges from 1 to 366. (The last day of year differs by years.)
-fn ordinal0(&self) -> u32[src]Returns the day of year starting from 0.
-The return value ranges from 0 to 365. (The last day of year differs by years.)
-fn weekday(&self) -> Weekday[src]Returns the day of week.
-fn iso_week(&self) -> IsoWeek[src]Returns the ISO week.
-fn with_year(&self, year: i32) -> Option<Self>[src]Makes a new value with the year number changed.
-Returns None when the resulting value would be invalid.
fn with_month(&self, month: u32) -> Option<Self>[src]Makes a new value with the month number (starting from 1) changed.
-Returns None when the resulting value would be invalid.
fn with_month0(&self, month0: u32) -> Option<Self>[src]Makes a new value with the month number (starting from 0) changed.
-Returns None when the resulting value would be invalid.
fn with_day(&self, day: u32) -> Option<Self>[src]Makes a new value with the day of month (starting from 1) changed.
-Returns None when the resulting value would be invalid.
fn with_day0(&self, day0: u32) -> Option<Self>[src]Makes a new value with the day of month (starting from 0) changed.
-Returns None when the resulting value would be invalid.
fn with_ordinal(&self, ordinal: u32) -> Option<Self>[src]Makes a new value with the day of year (starting from 1) changed.
-Returns None when the resulting value would be invalid.
fn with_ordinal0(&self, ordinal0: u32) -> Option<Self>[src]Makes a new value with the day of year (starting from 0) changed.
-Returns None when the resulting value would be invalid.
fn year_ce(&self) -> (bool, u32)[src]Returns the absolute year number starting from 1 with a boolean flag, -which is false when the year predates the epoch (BCE/BC) and true otherwise (CE/AD).
-fn num_days_from_ce(&self) -> i32[src]Counts the days in the proleptic Gregorian calendar, with January 1, Year 1 (CE) as day 1.
--use chrono::{NaiveDate, Datelike}; - -assert_eq!(NaiveDate::from_ymd(1970, 1, 1).num_days_from_ce(), 719_163); -assert_eq!(NaiveDate::from_ymd(2, 1, 1).num_days_from_ce(), 366); -assert_eq!(NaiveDate::from_ymd(1, 1, 1).num_days_from_ce(), 1); -assert_eq!(NaiveDate::from_ymd(0, 1, 1).num_days_from_ce(), -365);
impl Datelike for NaiveDate[src]fn year(&self) -> i32[src]Returns the year number in the calendar date.
--use chrono::{NaiveDate, Datelike}; - -assert_eq!(NaiveDate::from_ymd(2015, 9, 8).year(), 2015); -assert_eq!(NaiveDate::from_ymd(-308, 3, 14).year(), -308); // 309 BCE
fn month(&self) -> u32[src]Returns the month number starting from 1.
-The return value ranges from 1 to 12.
--use chrono::{NaiveDate, Datelike}; - -assert_eq!(NaiveDate::from_ymd(2015, 9, 8).month(), 9); -assert_eq!(NaiveDate::from_ymd(-308, 3, 14).month(), 3);
fn month0(&self) -> u32[src]Returns the month number starting from 0.
-The return value ranges from 0 to 11.
--use chrono::{NaiveDate, Datelike}; - -assert_eq!(NaiveDate::from_ymd(2015, 9, 8).month0(), 8); -assert_eq!(NaiveDate::from_ymd(-308, 3, 14).month0(), 2);
fn day(&self) -> u32[src]Returns the day of month starting from 1.
-The return value ranges from 1 to 31. (The last day of month differs by months.)
--use chrono::{NaiveDate, Datelike}; - -assert_eq!(NaiveDate::from_ymd(2015, 9, 8).day(), 8); -assert_eq!(NaiveDate::from_ymd(-308, 3, 14).day(), 14);
Combined with NaiveDate::pred,
-one can determine the number of days in a particular month.
-(Note that this panics when year is out of range.)
-use chrono::{NaiveDate, Datelike}; - -fn ndays_in_month(year: i32, month: u32) -> u32 { - // the first day of the next month... - let (y, m) = if month == 12 { (year + 1, 1) } else { (year, month + 1) }; - let d = NaiveDate::from_ymd(y, m, 1); - - // ...is preceded by the last day of the original month - d.pred().day() -} - -assert_eq!(ndays_in_month(2015, 8), 31); -assert_eq!(ndays_in_month(2015, 9), 30); -assert_eq!(ndays_in_month(2015, 12), 31); -assert_eq!(ndays_in_month(2016, 2), 29); -assert_eq!(ndays_in_month(2017, 2), 28);
fn day0(&self) -> u32[src]Returns the day of month starting from 0.
-The return value ranges from 0 to 30. (The last day of month differs by months.)
--use chrono::{NaiveDate, Datelike}; - -assert_eq!(NaiveDate::from_ymd(2015, 9, 8).day0(), 7); -assert_eq!(NaiveDate::from_ymd(-308, 3, 14).day0(), 13);
fn ordinal(&self) -> u32[src]Returns the day of year starting from 1.
-The return value ranges from 1 to 366. (The last day of year differs by years.)
--use chrono::{NaiveDate, Datelike}; - -assert_eq!(NaiveDate::from_ymd(2015, 9, 8).ordinal(), 251); -assert_eq!(NaiveDate::from_ymd(-308, 3, 14).ordinal(), 74);
Combined with NaiveDate::pred,
-one can determine the number of days in a particular year.
-(Note that this panics when year is out of range.)
-use chrono::{NaiveDate, Datelike}; - -fn ndays_in_year(year: i32) -> u32 { - // the first day of the next year... - let d = NaiveDate::from_ymd(year + 1, 1, 1); - - // ...is preceded by the last day of the original year - d.pred().ordinal() -} - -assert_eq!(ndays_in_year(2015), 365); -assert_eq!(ndays_in_year(2016), 366); -assert_eq!(ndays_in_year(2017), 365); -assert_eq!(ndays_in_year(2000), 366); -assert_eq!(ndays_in_year(2100), 365);
fn ordinal0(&self) -> u32[src]Returns the day of year starting from 0.
-The return value ranges from 0 to 365. (The last day of year differs by years.)
--use chrono::{NaiveDate, Datelike}; - -assert_eq!(NaiveDate::from_ymd(2015, 9, 8).ordinal0(), 250); -assert_eq!(NaiveDate::from_ymd(-308, 3, 14).ordinal0(), 73);
fn weekday(&self) -> Weekday[src]Returns the day of week.
--use chrono::{NaiveDate, Datelike, Weekday}; - -assert_eq!(NaiveDate::from_ymd(2015, 9, 8).weekday(), Weekday::Tue); -assert_eq!(NaiveDate::from_ymd(-308, 3, 14).weekday(), Weekday::Fri);
fn iso_week(&self) -> IsoWeek[src]fn with_year(&self, year: i32) -> Option<NaiveDate>[src]Makes a new NaiveDate with the year number changed.
Returns None when the resulting NaiveDate would be invalid.
-use chrono::{NaiveDate, Datelike}; - -assert_eq!(NaiveDate::from_ymd(2015, 9, 8).with_year(2016), - Some(NaiveDate::from_ymd(2016, 9, 8))); -assert_eq!(NaiveDate::from_ymd(2015, 9, 8).with_year(-308), - Some(NaiveDate::from_ymd(-308, 9, 8)));
A leap day (February 29) is a good example that this method can return None.
-assert!(NaiveDate::from_ymd(2016, 2, 29).with_year(2015).is_none()); -assert!(NaiveDate::from_ymd(2016, 2, 29).with_year(2020).is_some());
fn with_month(&self, month: u32) -> Option<NaiveDate>[src]Makes a new NaiveDate with the month number (starting from 1) changed.
Returns None when the resulting NaiveDate would be invalid.
-use chrono::{NaiveDate, Datelike}; - -assert_eq!(NaiveDate::from_ymd(2015, 9, 8).with_month(10), - Some(NaiveDate::from_ymd(2015, 10, 8))); -assert_eq!(NaiveDate::from_ymd(2015, 9, 8).with_month(13), None); // no month 13 -assert_eq!(NaiveDate::from_ymd(2015, 9, 30).with_month(2), None); // no February 30
fn with_month0(&self, month0: u32) -> Option<NaiveDate>[src]Makes a new NaiveDate with the month number (starting from 0) changed.
Returns None when the resulting NaiveDate would be invalid.
-use chrono::{NaiveDate, Datelike}; - -assert_eq!(NaiveDate::from_ymd(2015, 9, 8).with_month0(9), - Some(NaiveDate::from_ymd(2015, 10, 8))); -assert_eq!(NaiveDate::from_ymd(2015, 9, 8).with_month0(12), None); // no month 13 -assert_eq!(NaiveDate::from_ymd(2015, 9, 30).with_month0(1), None); // no February 30
fn with_day(&self, day: u32) -> Option<NaiveDate>[src]Makes a new NaiveDate with the day of month (starting from 1) changed.
Returns None when the resulting NaiveDate would be invalid.
-use chrono::{NaiveDate, Datelike}; - -assert_eq!(NaiveDate::from_ymd(2015, 9, 8).with_day(30), - Some(NaiveDate::from_ymd(2015, 9, 30))); -assert_eq!(NaiveDate::from_ymd(2015, 9, 8).with_day(31), - None); // no September 31
fn with_day0(&self, day0: u32) -> Option<NaiveDate>[src]Makes a new NaiveDate with the day of month (starting from 0) changed.
Returns None when the resulting NaiveDate would be invalid.
-use chrono::{NaiveDate, Datelike}; - -assert_eq!(NaiveDate::from_ymd(2015, 9, 8).with_day0(29), - Some(NaiveDate::from_ymd(2015, 9, 30))); -assert_eq!(NaiveDate::from_ymd(2015, 9, 8).with_day0(30), - None); // no September 31
fn with_ordinal(&self, ordinal: u32) -> Option<NaiveDate>[src]Makes a new NaiveDate with the day of year (starting from 1) changed.
Returns None when the resulting NaiveDate would be invalid.
-use chrono::{NaiveDate, Datelike}; - -assert_eq!(NaiveDate::from_ymd(2015, 1, 1).with_ordinal(60), - Some(NaiveDate::from_ymd(2015, 3, 1))); -assert_eq!(NaiveDate::from_ymd(2015, 1, 1).with_ordinal(366), - None); // 2015 had only 365 days - -assert_eq!(NaiveDate::from_ymd(2016, 1, 1).with_ordinal(60), - Some(NaiveDate::from_ymd(2016, 2, 29))); -assert_eq!(NaiveDate::from_ymd(2016, 1, 1).with_ordinal(366), - Some(NaiveDate::from_ymd(2016, 12, 31)));
fn with_ordinal0(&self, ordinal0: u32) -> Option<NaiveDate>[src]Makes a new NaiveDate with the day of year (starting from 0) changed.
Returns None when the resulting NaiveDate would be invalid.
-use chrono::{NaiveDate, Datelike}; - -assert_eq!(NaiveDate::from_ymd(2015, 1, 1).with_ordinal0(59), - Some(NaiveDate::from_ymd(2015, 3, 1))); -assert_eq!(NaiveDate::from_ymd(2015, 1, 1).with_ordinal0(365), - None); // 2015 had only 365 days - -assert_eq!(NaiveDate::from_ymd(2016, 1, 1).with_ordinal0(59), - Some(NaiveDate::from_ymd(2016, 2, 29))); -assert_eq!(NaiveDate::from_ymd(2016, 1, 1).with_ordinal0(365), - Some(NaiveDate::from_ymd(2016, 12, 31)));
impl Datelike for NaiveDateTime[src]fn year(&self) -> i32[src]Returns the year number in the calendar date.
-See also the NaiveDate::year method.
-use chrono::{NaiveDate, NaiveDateTime, Datelike}; - -let dt: NaiveDateTime = NaiveDate::from_ymd(2015, 9, 25).and_hms(12, 34, 56); -assert_eq!(dt.year(), 2015);
fn month(&self) -> u32[src]Returns the month number starting from 1.
-The return value ranges from 1 to 12.
-See also the NaiveDate::month method.
-use chrono::{NaiveDate, NaiveDateTime, Datelike}; - -let dt: NaiveDateTime = NaiveDate::from_ymd(2015, 9, 25).and_hms(12, 34, 56); -assert_eq!(dt.month(), 9);
fn month0(&self) -> u32[src]Returns the month number starting from 0.
-The return value ranges from 0 to 11.
-See also the NaiveDate::month0 method.
-use chrono::{NaiveDate, NaiveDateTime, Datelike}; - -let dt: NaiveDateTime = NaiveDate::from_ymd(2015, 9, 25).and_hms(12, 34, 56); -assert_eq!(dt.month0(), 8);
fn day(&self) -> u32[src]Returns the day of month starting from 1.
-The return value ranges from 1 to 31. (The last day of month differs by months.)
-See also the NaiveDate::day method.
-use chrono::{NaiveDate, NaiveDateTime, Datelike}; - -let dt: NaiveDateTime = NaiveDate::from_ymd(2015, 9, 25).and_hms(12, 34, 56); -assert_eq!(dt.day(), 25);
fn day0(&self) -> u32[src]Returns the day of month starting from 0.
-The return value ranges from 0 to 30. (The last day of month differs by months.)
-See also the NaiveDate::day0 method.
-use chrono::{NaiveDate, NaiveDateTime, Datelike}; - -let dt: NaiveDateTime = NaiveDate::from_ymd(2015, 9, 25).and_hms(12, 34, 56); -assert_eq!(dt.day0(), 24);
fn ordinal(&self) -> u32[src]Returns the day of year starting from 1.
-The return value ranges from 1 to 366. (The last day of year differs by years.)
-See also the NaiveDate::ordinal method.
-use chrono::{NaiveDate, NaiveDateTime, Datelike}; - -let dt: NaiveDateTime = NaiveDate::from_ymd(2015, 9, 25).and_hms(12, 34, 56); -assert_eq!(dt.ordinal(), 268);
fn ordinal0(&self) -> u32[src]Returns the day of year starting from 0.
-The return value ranges from 0 to 365. (The last day of year differs by years.)
-See also the NaiveDate::ordinal0 method.
-use chrono::{NaiveDate, NaiveDateTime, Datelike}; - -let dt: NaiveDateTime = NaiveDate::from_ymd(2015, 9, 25).and_hms(12, 34, 56); -assert_eq!(dt.ordinal0(), 267);
fn weekday(&self) -> Weekday[src]Returns the day of week.
-See also the NaiveDate::weekday method.
-use chrono::{NaiveDate, NaiveDateTime, Datelike, Weekday}; - -let dt: NaiveDateTime = NaiveDate::from_ymd(2015, 9, 25).and_hms(12, 34, 56); -assert_eq!(dt.weekday(), Weekday::Fri);
fn iso_week(&self) -> IsoWeek[src]fn with_year(&self, year: i32) -> Option<NaiveDateTime>[src]Makes a new NaiveDateTime with the year number changed.
Returns None when the resulting NaiveDateTime would be invalid.
See also the
-NaiveDate::with_year method.
-use chrono::{NaiveDate, NaiveDateTime, Datelike}; - -let dt: NaiveDateTime = NaiveDate::from_ymd(2015, 9, 25).and_hms(12, 34, 56); -assert_eq!(dt.with_year(2016), Some(NaiveDate::from_ymd(2016, 9, 25).and_hms(12, 34, 56))); -assert_eq!(dt.with_year(-308), Some(NaiveDate::from_ymd(-308, 9, 25).and_hms(12, 34, 56)));
fn with_month(&self, month: u32) -> Option<NaiveDateTime>[src]Makes a new NaiveDateTime with the month number (starting from 1) changed.
Returns None when the resulting NaiveDateTime would be invalid.
See also the
-NaiveDate::with_month method.
-use chrono::{NaiveDate, NaiveDateTime, Datelike}; - -let dt: NaiveDateTime = NaiveDate::from_ymd(2015, 9, 30).and_hms(12, 34, 56); -assert_eq!(dt.with_month(10), Some(NaiveDate::from_ymd(2015, 10, 30).and_hms(12, 34, 56))); -assert_eq!(dt.with_month(13), None); // no month 13 -assert_eq!(dt.with_month(2), None); // no February 30
fn with_month0(&self, month0: u32) -> Option<NaiveDateTime>[src]Makes a new NaiveDateTime with the month number (starting from 0) changed.
Returns None when the resulting NaiveDateTime would be invalid.
See also the
-NaiveDate::with_month0 method.
-use chrono::{NaiveDate, NaiveDateTime, Datelike}; - -let dt: NaiveDateTime = NaiveDate::from_ymd(2015, 9, 30).and_hms(12, 34, 56); -assert_eq!(dt.with_month0(9), Some(NaiveDate::from_ymd(2015, 10, 30).and_hms(12, 34, 56))); -assert_eq!(dt.with_month0(12), None); // no month 13 -assert_eq!(dt.with_month0(1), None); // no February 30
fn with_day(&self, day: u32) -> Option<NaiveDateTime>[src]Makes a new NaiveDateTime with the day of month (starting from 1) changed.
Returns None when the resulting NaiveDateTime would be invalid.
See also the
-NaiveDate::with_day method.
-use chrono::{NaiveDate, NaiveDateTime, Datelike}; - -let dt: NaiveDateTime = NaiveDate::from_ymd(2015, 9, 8).and_hms(12, 34, 56); -assert_eq!(dt.with_day(30), Some(NaiveDate::from_ymd(2015, 9, 30).and_hms(12, 34, 56))); -assert_eq!(dt.with_day(31), None); // no September 31
fn with_day0(&self, day0: u32) -> Option<NaiveDateTime>[src]Makes a new NaiveDateTime with the day of month (starting from 0) changed.
Returns None when the resulting NaiveDateTime would be invalid.
See also the
-NaiveDate::with_day0 method.
-use chrono::{NaiveDate, NaiveDateTime, Datelike}; - -let dt: NaiveDateTime = NaiveDate::from_ymd(2015, 9, 8).and_hms(12, 34, 56); -assert_eq!(dt.with_day0(29), Some(NaiveDate::from_ymd(2015, 9, 30).and_hms(12, 34, 56))); -assert_eq!(dt.with_day0(30), None); // no September 31
fn with_ordinal(&self, ordinal: u32) -> Option<NaiveDateTime>[src]Makes a new NaiveDateTime with the day of year (starting from 1) changed.
Returns None when the resulting NaiveDateTime would be invalid.
See also the
-NaiveDate::with_ordinal method.
-use chrono::{NaiveDate, NaiveDateTime, Datelike}; - -let dt: NaiveDateTime = NaiveDate::from_ymd(2015, 9, 8).and_hms(12, 34, 56); -assert_eq!(dt.with_ordinal(60), - Some(NaiveDate::from_ymd(2015, 3, 1).and_hms(12, 34, 56))); -assert_eq!(dt.with_ordinal(366), None); // 2015 had only 365 days - -let dt: NaiveDateTime = NaiveDate::from_ymd(2016, 9, 8).and_hms(12, 34, 56); -assert_eq!(dt.with_ordinal(60), - Some(NaiveDate::from_ymd(2016, 2, 29).and_hms(12, 34, 56))); -assert_eq!(dt.with_ordinal(366), - Some(NaiveDate::from_ymd(2016, 12, 31).and_hms(12, 34, 56)));
fn with_ordinal0(&self, ordinal0: u32) -> Option<NaiveDateTime>[src]Makes a new NaiveDateTime with the day of year (starting from 0) changed.
Returns None when the resulting NaiveDateTime would be invalid.
See also the
-NaiveDate::with_ordinal0 method.
-use chrono::{NaiveDate, NaiveDateTime, Datelike}; - -let dt: NaiveDateTime = NaiveDate::from_ymd(2015, 9, 8).and_hms(12, 34, 56); -assert_eq!(dt.with_ordinal0(59), - Some(NaiveDate::from_ymd(2015, 3, 1).and_hms(12, 34, 56))); -assert_eq!(dt.with_ordinal0(365), None); // 2015 had only 365 days - -let dt: NaiveDateTime = NaiveDate::from_ymd(2016, 9, 8).and_hms(12, 34, 56); -assert_eq!(dt.with_ordinal0(59), - Some(NaiveDate::from_ymd(2016, 2, 29).and_hms(12, 34, 56))); -assert_eq!(dt.with_ordinal0(365), - Some(NaiveDate::from_ymd(2016, 12, 31).and_hms(12, 34, 56)));
impl<Tz: TimeZone> Datelike for Date<Tz>[src]fn year(&self) -> i32[src]fn month(&self) -> u32[src]fn month0(&self) -> u32[src]fn day(&self) -> u32[src]fn day0(&self) -> u32[src]fn ordinal(&self) -> u32[src]fn ordinal0(&self) -> u32[src]fn weekday(&self) -> Weekday[src]fn iso_week(&self) -> IsoWeek[src]fn with_year(&self, year: i32) -> Option<Date<Tz>>[src]fn with_month(&self, month: u32) -> Option<Date<Tz>>[src]fn with_month0(&self, month0: u32) -> Option<Date<Tz>>[src]fn with_day(&self, day: u32) -> Option<Date<Tz>>[src]fn with_day0(&self, day0: u32) -> Option<Date<Tz>>[src]fn with_ordinal(&self, ordinal: u32) -> Option<Date<Tz>>[src]fn with_ordinal0(&self, ordinal0: u32) -> Option<Date<Tz>>[src]impl<Tz: TimeZone> Datelike for DateTime<Tz>[src]fn year(&self) -> i32[src]fn month(&self) -> u32[src]fn month0(&self) -> u32[src]fn day(&self) -> u32[src]fn day0(&self) -> u32[src]fn ordinal(&self) -> u32[src]fn ordinal0(&self) -> u32[src]fn weekday(&self) -> Weekday[src]fn iso_week(&self) -> IsoWeek[src]fn with_year(&self, year: i32) -> Option<DateTime<Tz>>[src]fn with_month(&self, month: u32) -> Option<DateTime<Tz>>[src]fn with_month0(&self, month0: u32) -> Option<DateTime<Tz>>[src]fn with_day(&self, day: u32) -> Option<DateTime<Tz>>[src]fn with_day0(&self, day0: u32) -> Option<DateTime<Tz>>[src]fn with_ordinal(&self, ordinal: u32) -> Option<DateTime<Tz>>[src]fn with_ordinal0(&self, ordinal0: u32) -> Option<DateTime<Tz>>[src]Extension trait for rounding or truncating a DateTime by a Duration.
-Both rounding and truncating are done via Duration::num_nanoseconds and
-DateTime::timestamp_nanos. This means that they will fail if either the
-Duration or the DateTime are too big to represented as nanoseconds. They
-will also fail if the Duration is bigger than the timestamp.
fn duration_round(self, duration: Duration) -> Result<Self, Self::Err>[src]Return a copy rounded by Duration.
--let dt = Utc.ymd(2018, 1, 11).and_hms_milli(12, 0, 0, 154); -assert_eq!( - dt.duration_round(Duration::milliseconds(10)).unwrap().to_string(), - "2018-01-11 12:00:00.150 UTC" -); -assert_eq!( - dt.duration_round(Duration::days(1)).unwrap().to_string(), - "2018-01-12 00:00:00 UTC" -);
fn duration_trunc(self, duration: Duration) -> Result<Self, Self::Err>[src]Return a copy truncated by Duration.
--let dt = Utc.ymd(2018, 1, 11).and_hms_milli(12, 0, 0, 154); -assert_eq!( - dt.duration_trunc(Duration::milliseconds(10)).unwrap().to_string(), - "2018-01-11 12:00:00.150 UTC" -); -assert_eq!( - dt.duration_trunc(Duration::days(1)).unwrap().to_string(), - "2018-01-11 00:00:00 UTC" -);
impl<Tz: TimeZone> DurationRound for DateTime<Tz>[src]type Err = RoundingErrorfn duration_round(self, duration: Duration) -> Result<Self, Self::Err>[src]fn duration_trunc(self, duration: Duration) -> Result<Self, Self::Err>[src]Extension trait for subsecond rounding or truncation to a maximum number -of digits. Rounding can be used to decrease the error variance when -serializing/persisting to lower precision. Truncation is the default -behavior in Chrono display formatting. Either can be used to guarantee -equality (e.g. for testing) when round-tripping through a lower precision -format.
-fn round_subsecs(self, digits: u16) -> Self[src]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).
--let dt = Utc.ymd(2018, 1, 11).and_hms_milli(12, 0, 0, 154); -assert_eq!(dt.round_subsecs(2).nanosecond(), 150_000_000); -assert_eq!(dt.round_subsecs(1).nanosecond(), 200_000_000);
fn trunc_subsecs(self, digits: u16) -> Self[src]Return a copy truncated to the specified number of subsecond -digits. With 9 or more digits, self is returned unmodified.
--let dt = Utc.ymd(2018, 1, 11).and_hms_milli(12, 0, 0, 154); -assert_eq!(dt.trunc_subsecs(2).nanosecond(), 150_000_000); -assert_eq!(dt.trunc_subsecs(1).nanosecond(), 100_000_000);
impl<T> SubsecRound for T where
T: Timelike + Add<Duration, Output = T> + Sub<Duration, Output = T>, [src]fn round_subsecs(self, digits: u16) -> T[src]fn trunc_subsecs(self, digits: u16) -> T[src]The common set of methods for time component.
-fn hour(&self) -> u32[src]Returns the hour number from 0 to 23.
-fn minute(&self) -> u32[src]Returns the minute number from 0 to 59.
-fn second(&self) -> u32[src]Returns the second number from 0 to 59.
-fn nanosecond(&self) -> u32[src]Returns the number of nanoseconds since the whole non-leap second. -The range from 1,000,000,000 to 1,999,999,999 represents -the leap second.
-fn with_hour(&self, hour: u32) -> Option<Self>[src]Makes a new value with the hour number changed.
-Returns None when the resulting value would be invalid.
fn with_minute(&self, min: u32) -> Option<Self>[src]Makes a new value with the minute number changed.
-Returns None when the resulting value would be invalid.
fn with_second(&self, sec: u32) -> Option<Self>[src]Makes a new value with the second number changed.
-Returns None when the resulting value would be invalid.
-As with the second method,
-the input range is restricted to 0 through 59.
fn with_nanosecond(&self, nano: u32) -> Option<Self>[src]Makes a new value with nanoseconds since the whole non-leap second changed.
-Returns None when the resulting value would be invalid.
-As with the nanosecond method,
-the input range can exceed 1,000,000,000 for leap seconds.
fn hour12(&self) -> (bool, u32)[src]Returns the hour number from 1 to 12 with a boolean flag, -which is false for AM and true for PM.
-fn num_seconds_from_midnight(&self) -> u32[src]Returns the number of non-leap seconds past the last midnight.
-impl Timelike for NaiveDateTime[src]fn hour(&self) -> u32[src]Returns the hour number from 0 to 23.
-See also the NaiveTime::hour method.
-use chrono::{NaiveDate, NaiveDateTime, Timelike}; - -let dt: NaiveDateTime = NaiveDate::from_ymd(2015, 9, 8).and_hms_milli(12, 34, 56, 789); -assert_eq!(dt.hour(), 12);
fn minute(&self) -> u32[src]Returns the minute number from 0 to 59.
-See also the NaiveTime::minute method.
-use chrono::{NaiveDate, NaiveDateTime, Timelike}; - -let dt: NaiveDateTime = NaiveDate::from_ymd(2015, 9, 8).and_hms_milli(12, 34, 56, 789); -assert_eq!(dt.minute(), 34);
fn second(&self) -> u32[src]Returns the second number from 0 to 59.
-See also the NaiveTime::second method.
-use chrono::{NaiveDate, NaiveDateTime, Timelike}; - -let dt: NaiveDateTime = NaiveDate::from_ymd(2015, 9, 8).and_hms_milli(12, 34, 56, 789); -assert_eq!(dt.second(), 56);
fn nanosecond(&self) -> u32[src]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.
-See also the
-NaiveTime::nanosecond method.
-use chrono::{NaiveDate, NaiveDateTime, Timelike}; - -let dt: NaiveDateTime = NaiveDate::from_ymd(2015, 9, 8).and_hms_milli(12, 34, 56, 789); -assert_eq!(dt.nanosecond(), 789_000_000);
fn with_hour(&self, hour: u32) -> Option<NaiveDateTime>[src]Makes a new NaiveDateTime with the hour number changed.
Returns None when the resulting NaiveDateTime would be invalid.
See also the
-NaiveTime::with_hour method.
-use chrono::{NaiveDate, NaiveDateTime, Timelike}; - -let dt: NaiveDateTime = NaiveDate::from_ymd(2015, 9, 8).and_hms_milli(12, 34, 56, 789); -assert_eq!(dt.with_hour(7), - Some(NaiveDate::from_ymd(2015, 9, 8).and_hms_milli(7, 34, 56, 789))); -assert_eq!(dt.with_hour(24), None);
fn with_minute(&self, min: u32) -> Option<NaiveDateTime>[src]Makes a new NaiveDateTime with the minute number changed.
Returns None when the resulting NaiveDateTime would be invalid.
See also the
-NaiveTime::with_minute method.
-use chrono::{NaiveDate, NaiveDateTime, Timelike}; - -let dt: NaiveDateTime = NaiveDate::from_ymd(2015, 9, 8).and_hms_milli(12, 34, 56, 789); -assert_eq!(dt.with_minute(45), - Some(NaiveDate::from_ymd(2015, 9, 8).and_hms_milli(12, 45, 56, 789))); -assert_eq!(dt.with_minute(60), None);
fn with_second(&self, sec: u32) -> Option<NaiveDateTime>[src]Makes a new NaiveDateTime with the second number changed.
Returns None when the resulting NaiveDateTime would be invalid.
-As with the second method,
-the input range is restricted to 0 through 59.
See also the
-NaiveTime::with_second method.
-use chrono::{NaiveDate, NaiveDateTime, Timelike}; - -let dt: NaiveDateTime = NaiveDate::from_ymd(2015, 9, 8).and_hms_milli(12, 34, 56, 789); -assert_eq!(dt.with_second(17), - Some(NaiveDate::from_ymd(2015, 9, 8).and_hms_milli(12, 34, 17, 789))); -assert_eq!(dt.with_second(60), None);
fn with_nanosecond(&self, nano: u32) -> Option<NaiveDateTime>[src]Makes a new NaiveDateTime with nanoseconds since the whole non-leap second changed.
Returns None when the resulting NaiveDateTime would be invalid.
-As with the nanosecond method,
-the input range can exceed 1,000,000,000 for leap seconds.
See also the
-NaiveTime::with_nanosecond
-method.
-use chrono::{NaiveDate, NaiveDateTime, Timelike}; - -let dt: NaiveDateTime = NaiveDate::from_ymd(2015, 9, 8).and_hms_milli(12, 34, 56, 789); -assert_eq!(dt.with_nanosecond(333_333_333), - Some(NaiveDate::from_ymd(2015, 9, 8).and_hms_nano(12, 34, 56, 333_333_333))); -assert_eq!(dt.with_nanosecond(1_333_333_333), // leap second - Some(NaiveDate::from_ymd(2015, 9, 8).and_hms_nano(12, 34, 56, 1_333_333_333))); -assert_eq!(dt.with_nanosecond(2_000_000_000), None);
impl Timelike for NaiveTime[src]fn hour(&self) -> u32[src]Returns the hour number from 0 to 23.
--use chrono::{NaiveTime, Timelike}; - -assert_eq!(NaiveTime::from_hms(0, 0, 0).hour(), 0); -assert_eq!(NaiveTime::from_hms_nano(23, 56, 4, 12_345_678).hour(), 23);
fn minute(&self) -> u32[src]Returns the minute number from 0 to 59.
--use chrono::{NaiveTime, Timelike}; - -assert_eq!(NaiveTime::from_hms(0, 0, 0).minute(), 0); -assert_eq!(NaiveTime::from_hms_nano(23, 56, 4, 12_345_678).minute(), 56);
fn second(&self) -> u32[src]Returns the second number from 0 to 59.
--use chrono::{NaiveTime, Timelike}; - -assert_eq!(NaiveTime::from_hms(0, 0, 0).second(), 0); -assert_eq!(NaiveTime::from_hms_nano(23, 56, 4, 12_345_678).second(), 4);
This method never returns 60 even when it is a leap second. -(Why?) -Use the proper formatting method to get a human-readable representation.
- --let leap = NaiveTime::from_hms_milli(23, 59, 59, 1_000); -assert_eq!(leap.second(), 59); -assert_eq!(leap.format("%H:%M:%S").to_string(), "23:59:60");
fn nanosecond(&self) -> u32[src]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.
--use chrono::{NaiveTime, Timelike}; - -assert_eq!(NaiveTime::from_hms(0, 0, 0).nanosecond(), 0); -assert_eq!(NaiveTime::from_hms_nano(23, 56, 4, 12_345_678).nanosecond(), 12_345_678);
Leap seconds may have seemingly out-of-range return values.
-You can reduce the range with time.nanosecond() % 1_000_000_000, or
-use the proper formatting method to get a human-readable representation.
-let leap = NaiveTime::from_hms_milli(23, 59, 59, 1_000); -assert_eq!(leap.nanosecond(), 1_000_000_000); -assert_eq!(leap.format("%H:%M:%S%.9f").to_string(), "23:59:60.000000000");
fn with_hour(&self, hour: u32) -> Option<NaiveTime>[src]Makes a new NaiveTime with the hour number changed.
Returns None when the resulting NaiveTime would be invalid.
-use chrono::{NaiveTime, Timelike}; - -let dt = NaiveTime::from_hms_nano(23, 56, 4, 12_345_678); -assert_eq!(dt.with_hour(7), Some(NaiveTime::from_hms_nano(7, 56, 4, 12_345_678))); -assert_eq!(dt.with_hour(24), None);
fn with_minute(&self, min: u32) -> Option<NaiveTime>[src]Makes a new NaiveTime with the minute number changed.
Returns None when the resulting NaiveTime would be invalid.
-use chrono::{NaiveTime, Timelike}; - -let dt = NaiveTime::from_hms_nano(23, 56, 4, 12_345_678); -assert_eq!(dt.with_minute(45), Some(NaiveTime::from_hms_nano(23, 45, 4, 12_345_678))); -assert_eq!(dt.with_minute(60), None);
fn with_second(&self, sec: u32) -> Option<NaiveTime>[src]Makes a new NaiveTime with the second number changed.
Returns None when the resulting NaiveTime would be invalid.
-As with the second method,
-the input range is restricted to 0 through 59.
-use chrono::{NaiveTime, Timelike}; - -let dt = NaiveTime::from_hms_nano(23, 56, 4, 12_345_678); -assert_eq!(dt.with_second(17), Some(NaiveTime::from_hms_nano(23, 56, 17, 12_345_678))); -assert_eq!(dt.with_second(60), None);
fn with_nanosecond(&self, nano: u32) -> Option<NaiveTime>[src]Makes a new NaiveTime with nanoseconds since the whole non-leap second changed.
Returns None when the resulting NaiveTime would be invalid.
-As with the nanosecond method,
-the input range can exceed 1,000,000,000 for leap seconds.
-use chrono::{NaiveTime, Timelike}; - -let dt = NaiveTime::from_hms_nano(23, 56, 4, 12_345_678); -assert_eq!(dt.with_nanosecond(333_333_333), - Some(NaiveTime::from_hms_nano(23, 56, 4, 333_333_333))); -assert_eq!(dt.with_nanosecond(2_000_000_000), None);
Leap seconds can theoretically follow any whole second. -The following would be a proper leap second at the time zone offset of UTC-00:03:57 -(there are several historical examples comparable to this "non-sense" offset), -and therefore is allowed.
- --assert_eq!(dt.with_nanosecond(1_333_333_333), - Some(NaiveTime::from_hms_nano(23, 56, 4, 1_333_333_333)));
fn num_seconds_from_midnight(&self) -> u32[src]Returns the number of non-leap seconds past the last midnight.
--use chrono::{NaiveTime, Timelike}; - -assert_eq!(NaiveTime::from_hms(1, 2, 3).num_seconds_from_midnight(), - 3723); -assert_eq!(NaiveTime::from_hms_nano(23, 56, 4, 12_345_678).num_seconds_from_midnight(), - 86164); -assert_eq!(NaiveTime::from_hms_milli(23, 59, 59, 1_000).num_seconds_from_midnight(), - 86399);
impl<Tz: TimeZone> Timelike for DateTime<Tz>[src]fn hour(&self) -> u32[src]fn minute(&self) -> u32[src]fn second(&self) -> u32[src]fn nanosecond(&self) -> u32[src]fn with_hour(&self, hour: u32) -> Option<DateTime<Tz>>[src]fn with_minute(&self, min: u32) -> Option<DateTime<Tz>>[src]fn with_second(&self, sec: u32) -> Option<DateTime<Tz>>[src]fn with_nanosecond(&self, nano: u32) -> Option<DateTime<Tz>>[src]