Struct sqlx::types::chrono::NaiveDateTime [−][src]
pub struct NaiveDateTime { /* fields omitted */ }
Expand description
ISO 8601 combined date and time without timezone.
Example
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);
Implementations
impl NaiveDateTime
[src]
impl NaiveDateTime
[src]pub fn new(date: NaiveDate, time: NaiveTime) -> 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
.
Example
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]
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.
Example
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]
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.
Example
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) -> Result<NaiveDateTime, ParseError>
[src]
pub fn parse_from_str(s: &str, fmt: &str) -> Result<NaiveDateTime, ParseError>
[src]Parses a string with the specified format string and returns a new NaiveDateTime
.
See the format::strftime
module
on the supported escape sequences.
Example
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]
pub fn date(&self) -> NaiveDate
[src]Retrieves a date component.
Example
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]
pub fn time(&self) -> NaiveTime
[src]Retrieves a time component.
Example
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]
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.
Example
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]
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.)
Example
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]
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.
Panics
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.)
Example
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]
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.
Example
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]
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.
Example
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]
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.
Example
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: Duration) -> Option<NaiveDateTime>
[src]
pub fn checked_add_signed(self, rhs: Duration) -> 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.
Example
use chrono::{Duration, NaiveDate}; let from_ymd = NaiveDate::from_ymd; let d = from_ymd(2016, 7, 8); let hms = |h, m, s| d.and_hms(h, m, s); assert_eq!(hms(3, 5, 7).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: Duration) -> Option<NaiveDateTime>
[src]
pub fn checked_sub_signed(self, rhs: Duration) -> 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.
Example
use chrono::{Duration, NaiveDate}; let from_ymd = NaiveDate::from_ymd; let d = from_ymd(2016, 7, 8); let hms = |h, m, s| d.and_hms(h, m, s); assert_eq!(hms(3, 5, 7).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) -> Duration
[src]
pub fn signed_duration_since(self, rhs: NaiveDateTime) -> Duration
[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 NaiveDateTime
s themselves represents a leap second
in which case the assumption becomes that
there are exactly one (or two) leap second(s) ever.
Example
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]
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 Clone
able,
since the resulting DelayedFormat
value may be formatted multiple times.
Example
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(&self, fmt: &'a str) -> DelayedFormat<StrftimeItems<'a>>
[src]
pub fn format(&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.
Example
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");
Trait Implementations
impl Add<Duration> for NaiveDateTime
[src]
impl Add<Duration> for NaiveDateTime
[src]An addition of Duration
to NaiveDateTime
yields another NaiveDateTime
.
As a part of Chronoâs leap second handling,
the addition assumes that there is no leap second ever,
except when the NaiveDateTime
itself represents a leap second
in which case the assumption becomes that there is exactly a single leap second ever.
Panics on underflow or overflow.
Use NaiveDateTime::checked_add_signed
to detect that.
Example
use chrono::{Duration, NaiveDate}; let from_ymd = NaiveDate::from_ymd; let d = from_ymd(2016, 7, 8); let hms = |h, m, s| d.and_hms(h, m, s); assert_eq!(hms(3, 5, 7) + Duration::zero(), hms(3, 5, 7)); assert_eq!(hms(3, 5, 7) + Duration::seconds(1), hms(3, 5, 8)); assert_eq!(hms(3, 5, 7) + Duration::seconds(-1), hms(3, 5, 6)); assert_eq!(hms(3, 5, 7) + Duration::seconds(3600 + 60), hms(4, 6, 7)); assert_eq!(hms(3, 5, 7) + Duration::seconds(86_400), from_ymd(2016, 7, 9).and_hms(3, 5, 7)); assert_eq!(hms(3, 5, 7) + Duration::days(365), from_ymd(2017, 7, 8).and_hms(3, 5, 7)); let hmsm = |h, m, s, milli| d.and_hms_milli(h, m, s, milli); assert_eq!(hmsm(3, 5, 7, 980) + Duration::milliseconds(450), hmsm(3, 5, 8, 430));
Leap seconds are handled, but the addition assumes that it is the only leap second happened.
let leap = hmsm(3, 5, 59, 1_300); assert_eq!(leap + Duration::zero(), hmsm(3, 5, 59, 1_300)); assert_eq!(leap + Duration::milliseconds(-500), hmsm(3, 5, 59, 800)); assert_eq!(leap + Duration::milliseconds(500), hmsm(3, 5, 59, 1_800)); assert_eq!(leap + Duration::milliseconds(800), hmsm(3, 6, 0, 100)); assert_eq!(leap + Duration::seconds(10), hmsm(3, 6, 9, 300)); assert_eq!(leap + Duration::seconds(-10), hmsm(3, 5, 50, 300)); assert_eq!(leap + Duration::days(1), from_ymd(2016, 7, 9).and_hms_milli(3, 5, 59, 300));
type Output = NaiveDateTime
type Output = NaiveDateTime
The resulting type after applying the +
operator.
pub fn add(self, rhs: Duration) -> NaiveDateTime
[src]
pub fn add(self, rhs: Duration) -> NaiveDateTime
[src]Performs the +
operation. Read more
impl Add<FixedOffset> for NaiveDateTime
[src]
impl Add<FixedOffset> for NaiveDateTime
[src]type Output = NaiveDateTime
type Output = NaiveDateTime
The resulting type after applying the +
operator.
pub fn add(self, rhs: FixedOffset) -> NaiveDateTime
[src]
pub fn add(self, rhs: FixedOffset) -> NaiveDateTime
[src]Performs the +
operation. Read more
impl AddAssign<Duration> for NaiveDateTime
[src]
impl AddAssign<Duration> for NaiveDateTime
[src]pub fn add_assign(&mut self, rhs: Duration)
[src]
pub fn add_assign(&mut self, rhs: Duration)
[src]Performs the +=
operation. Read more
impl Clone for NaiveDateTime
[src]
impl Clone for NaiveDateTime
[src]pub fn clone(&self) -> NaiveDateTime
[src]
pub fn clone(&self) -> NaiveDateTime
[src]Returns a copy of the value. Read more
fn clone_from(&mut self, source: &Self)
1.0.0[src]
fn clone_from(&mut self, source: &Self)
1.0.0[src]Performs copy-assignment from source
. Read more
impl Datelike for NaiveDateTime
[src]
impl Datelike for NaiveDateTime
[src]pub fn year(&self) -> i32
[src]
pub fn year(&self) -> i32
[src]Returns the year number in the calendar date.
See also the NaiveDate::year
method.
Example
use chrono::{NaiveDate, NaiveDateTime, Datelike}; let dt: NaiveDateTime = NaiveDate::from_ymd(2015, 9, 25).and_hms(12, 34, 56); assert_eq!(dt.year(), 2015);
pub fn month(&self) -> u32
[src]
pub 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.
Example
use chrono::{NaiveDate, NaiveDateTime, Datelike}; let dt: NaiveDateTime = NaiveDate::from_ymd(2015, 9, 25).and_hms(12, 34, 56); assert_eq!(dt.month(), 9);
pub fn month0(&self) -> u32
[src]
pub 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.
Example
use chrono::{NaiveDate, NaiveDateTime, Datelike}; let dt: NaiveDateTime = NaiveDate::from_ymd(2015, 9, 25).and_hms(12, 34, 56); assert_eq!(dt.month0(), 8);
pub fn day(&self) -> u32
[src]
pub 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.
Example
use chrono::{NaiveDate, NaiveDateTime, Datelike}; let dt: NaiveDateTime = NaiveDate::from_ymd(2015, 9, 25).and_hms(12, 34, 56); assert_eq!(dt.day(), 25);
pub fn day0(&self) -> u32
[src]
pub 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.
Example
use chrono::{NaiveDate, NaiveDateTime, Datelike}; let dt: NaiveDateTime = NaiveDate::from_ymd(2015, 9, 25).and_hms(12, 34, 56); assert_eq!(dt.day0(), 24);
pub fn ordinal(&self) -> u32
[src]
pub 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.
Example
use chrono::{NaiveDate, NaiveDateTime, Datelike}; let dt: NaiveDateTime = NaiveDate::from_ymd(2015, 9, 25).and_hms(12, 34, 56); assert_eq!(dt.ordinal(), 268);
pub fn ordinal0(&self) -> u32
[src]
pub 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.
Example
use chrono::{NaiveDate, NaiveDateTime, Datelike}; let dt: NaiveDateTime = NaiveDate::from_ymd(2015, 9, 25).and_hms(12, 34, 56); assert_eq!(dt.ordinal0(), 267);
pub fn weekday(&self) -> Weekday
[src]
pub fn weekday(&self) -> Weekday
[src]Returns the day of week.
See also the NaiveDate::weekday
method.
Example
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);
pub fn with_year(&self, year: i32) -> Option<NaiveDateTime>
[src]
pub 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.
Example
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)));
pub fn with_month(&self, month: u32) -> Option<NaiveDateTime>
[src]
pub 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.
Example
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
pub fn with_month0(&self, month0: u32) -> Option<NaiveDateTime>
[src]
pub 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.
Example
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
pub fn with_day(&self, day: u32) -> Option<NaiveDateTime>
[src]
pub 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.
Example
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
pub fn with_day0(&self, day0: u32) -> Option<NaiveDateTime>
[src]
pub 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.
Example
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
pub fn with_ordinal(&self, ordinal: u32) -> Option<NaiveDateTime>
[src]
pub 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.
Example
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)));
pub fn with_ordinal0(&self, ordinal0: u32) -> Option<NaiveDateTime>
[src]
pub 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.
Example
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 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). Read more
fn num_days_from_ce(&self) -> i32
[src]
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. Read more
impl Debug for NaiveDateTime
[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.)
Example
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<'r> Decode<'r, MySql> for NaiveDateTime
[src]
impl<'r> Decode<'r, MySql> for NaiveDateTime
[src]pub fn decode(
value: MySqlValueRef<'r>
) -> Result<NaiveDateTime, Box<dyn Error + 'static + Sync + Send, Global>>
[src]
pub fn decode(
value: MySqlValueRef<'r>
) -> Result<NaiveDateTime, Box<dyn Error + 'static + Sync + Send, Global>>
[src]Decode a new value of this type using a raw value from the database.
impl<'r> Decode<'r, Postgres> for NaiveDateTime
[src]
impl<'r> Decode<'r, Postgres> for NaiveDateTime
[src]pub fn decode(
value: PgValueRef<'r>
) -> Result<NaiveDateTime, Box<dyn Error + 'static + Sync + Send, Global>>
[src]
pub fn decode(
value: PgValueRef<'r>
) -> Result<NaiveDateTime, Box<dyn Error + 'static + Sync + Send, Global>>
[src]Decode a new value of this type using a raw value from the database.
impl<'r> Decode<'r, Sqlite> for NaiveDateTime
[src]
impl<'r> Decode<'r, Sqlite> for NaiveDateTime
[src]pub fn decode(
value: SqliteValueRef<'r>
) -> Result<NaiveDateTime, Box<dyn Error + 'static + Sync + Send, Global>>
[src]
pub fn decode(
value: SqliteValueRef<'r>
) -> Result<NaiveDateTime, Box<dyn Error + 'static + Sync + Send, Global>>
[src]Decode a new value of this type using a raw value from the database.
impl Display for NaiveDateTime
[src]
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.)
Example
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<'_> Encode<'_, MySql> for NaiveDateTime
[src]
impl<'_> Encode<'_, MySql> for NaiveDateTime
[src]pub fn encode_by_ref(&self, buf: &mut Vec<u8, Global>) -> IsNull
[src]
pub fn encode_by_ref(&self, buf: &mut Vec<u8, Global>) -> IsNull
[src]Writes the value of self
into buf
without moving self
. Read more
pub fn size_hint(&self) -> usize
[src]
#[must_use]fn encode(self, buf: &mut <DB as HasArguments<'q>>::ArgumentBuffer) -> IsNull
[src]
#[must_use]fn encode(self, buf: &mut <DB as HasArguments<'q>>::ArgumentBuffer) -> IsNull
[src]Writes the value of self
into buf
in the expected format for the database.
fn produces(&self) -> Option<<DB as Database>::TypeInfo>
[src]
impl<'_> Encode<'_, Postgres> for NaiveDateTime
[src]
impl<'_> Encode<'_, Postgres> for NaiveDateTime
[src]pub fn encode_by_ref(&self, buf: &mut PgArgumentBuffer) -> IsNull
[src]
pub fn encode_by_ref(&self, buf: &mut PgArgumentBuffer) -> IsNull
[src]Writes the value of self
into buf
without moving self
. Read more
pub fn size_hint(&self) -> usize
[src]
#[must_use]fn encode(self, buf: &mut <DB as HasArguments<'q>>::ArgumentBuffer) -> IsNull
[src]
#[must_use]fn encode(self, buf: &mut <DB as HasArguments<'q>>::ArgumentBuffer) -> IsNull
[src]Writes the value of self
into buf
in the expected format for the database.
fn produces(&self) -> Option<<DB as Database>::TypeInfo>
[src]
impl<'_> Encode<'_, Sqlite> for NaiveDateTime
[src]
impl<'_> Encode<'_, Sqlite> for NaiveDateTime
[src]pub fn encode_by_ref(
&self,
buf: &mut Vec<SqliteArgumentValue<'_>, Global>
) -> IsNull
[src]
pub fn encode_by_ref(
&self,
buf: &mut Vec<SqliteArgumentValue<'_>, Global>
) -> IsNull
[src]Writes the value of self
into buf
without moving self
. Read more
#[must_use]fn encode(self, buf: &mut <DB as HasArguments<'q>>::ArgumentBuffer) -> IsNull
[src]
#[must_use]fn encode(self, buf: &mut <DB as HasArguments<'q>>::ArgumentBuffer) -> IsNull
[src]Writes the value of self
into buf
in the expected format for the database.
fn produces(&self) -> Option<<DB as Database>::TypeInfo>
[src]
fn size_hint(&self) -> usize
[src]
impl FromStr 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
.
Example
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 = ParseError
type Err = ParseError
The associated error which can be returned from parsing.
pub fn from_str(s: &str) -> Result<NaiveDateTime, ParseError>
[src]
pub fn from_str(s: &str) -> Result<NaiveDateTime, ParseError>
[src]Parses a string s
to return a value of this type. Read more
impl Hash for 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.)
impl Ord for NaiveDateTime
[src]
impl Ord for NaiveDateTime
[src]impl PartialEq<NaiveDateTime> for NaiveDateTime
[src]
impl PartialEq<NaiveDateTime> for NaiveDateTime
[src]pub fn eq(&self, other: &NaiveDateTime) -> bool
[src]
pub fn eq(&self, other: &NaiveDateTime) -> bool
[src]This method tests for self
and other
values to be equal, and is used
by ==
. Read more
pub fn ne(&self, other: &NaiveDateTime) -> bool
[src]
pub fn ne(&self, other: &NaiveDateTime) -> bool
[src]This method tests for !=
.
impl PartialOrd<NaiveDateTime> for NaiveDateTime
[src]
impl PartialOrd<NaiveDateTime> for NaiveDateTime
[src]pub fn partial_cmp(&self, other: &NaiveDateTime) -> Option<Ordering>
[src]
pub fn partial_cmp(&self, other: &NaiveDateTime) -> Option<Ordering>
[src]This method returns an ordering between self
and other
values if one exists. Read more
#[must_use]fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]fn lt(&self, other: &Rhs) -> bool
1.0.0[src]This method tests less than (for self
and other
) and is used by the <
operator. Read more
#[must_use]fn le(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]fn le(&self, other: &Rhs) -> bool
1.0.0[src]This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
impl Sub<Duration> for NaiveDateTime
[src]
impl Sub<Duration> for NaiveDateTime
[src]A subtraction of Duration
from NaiveDateTime
yields another NaiveDateTime
.
It is the same as the addition with a negated Duration
.
As a part of Chronoâs leap second handling,
the addition assumes that there is no leap second ever,
except when the NaiveDateTime
itself represents a leap second
in which case the assumption becomes that there is exactly a single leap second ever.
Panics on underflow or overflow.
Use NaiveDateTime::checked_sub_signed
to detect that.
Example
use chrono::{Duration, NaiveDate}; let from_ymd = NaiveDate::from_ymd; let d = from_ymd(2016, 7, 8); let hms = |h, m, s| d.and_hms(h, m, s); assert_eq!(hms(3, 5, 7) - Duration::zero(), hms(3, 5, 7)); assert_eq!(hms(3, 5, 7) - Duration::seconds(1), hms(3, 5, 6)); assert_eq!(hms(3, 5, 7) - Duration::seconds(-1), hms(3, 5, 8)); assert_eq!(hms(3, 5, 7) - Duration::seconds(3600 + 60), hms(2, 4, 7)); assert_eq!(hms(3, 5, 7) - Duration::seconds(86_400), from_ymd(2016, 7, 7).and_hms(3, 5, 7)); assert_eq!(hms(3, 5, 7) - Duration::days(365), from_ymd(2015, 7, 9).and_hms(3, 5, 7)); let hmsm = |h, m, s, milli| d.and_hms_milli(h, m, s, milli); assert_eq!(hmsm(3, 5, 7, 450) - Duration::milliseconds(670), hmsm(3, 5, 6, 780));
Leap seconds are handled, but the subtraction assumes that it is the only leap second happened.
let leap = hmsm(3, 5, 59, 1_300); assert_eq!(leap - Duration::zero(), hmsm(3, 5, 59, 1_300)); assert_eq!(leap - Duration::milliseconds(200), hmsm(3, 5, 59, 1_100)); assert_eq!(leap - Duration::milliseconds(500), hmsm(3, 5, 59, 800)); assert_eq!(leap - Duration::seconds(60), hmsm(3, 5, 0, 300)); assert_eq!(leap - Duration::days(1), from_ymd(2016, 7, 7).and_hms_milli(3, 6, 0, 300));
type Output = NaiveDateTime
type Output = NaiveDateTime
The resulting type after applying the -
operator.
pub fn sub(self, rhs: Duration) -> NaiveDateTime
[src]
pub fn sub(self, rhs: Duration) -> NaiveDateTime
[src]Performs the -
operation. Read more
impl Sub<FixedOffset> for NaiveDateTime
[src]
impl Sub<FixedOffset> for NaiveDateTime
[src]type Output = NaiveDateTime
type Output = NaiveDateTime
The resulting type after applying the -
operator.
pub fn sub(self, rhs: FixedOffset) -> NaiveDateTime
[src]
pub fn sub(self, rhs: FixedOffset) -> NaiveDateTime
[src]Performs the -
operation. Read more
impl Sub<NaiveDateTime> for 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 NaiveDateTime
s 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
.
Example
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));
impl SubAssign<Duration> for NaiveDateTime
[src]
impl SubAssign<Duration> for NaiveDateTime
[src]pub fn sub_assign(&mut self, rhs: Duration)
[src]
pub fn sub_assign(&mut self, rhs: Duration)
[src]Performs the -=
operation. Read more
impl Timelike for NaiveDateTime
[src]
impl Timelike for NaiveDateTime
[src]pub fn hour(&self) -> u32
[src]
pub fn hour(&self) -> u32
[src]Returns the hour number from 0 to 23.
See also the NaiveTime::hour
method.
Example
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);
pub fn minute(&self) -> u32
[src]
pub fn minute(&self) -> u32
[src]Returns the minute number from 0 to 59.
See also the NaiveTime::minute
method.
Example
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);
pub fn second(&self) -> u32
[src]
pub fn second(&self) -> u32
[src]Returns the second number from 0 to 59.
See also the NaiveTime::second
method.
Example
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);
pub fn nanosecond(&self) -> u32
[src]
pub 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.
Example
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);
pub fn with_hour(&self, hour: u32) -> Option<NaiveDateTime>
[src]
pub 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.
Example
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);
pub fn with_minute(&self, min: u32) -> Option<NaiveDateTime>
[src]
pub 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.
Example
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);
pub fn with_second(&self, sec: u32) -> Option<NaiveDateTime>
[src]
pub 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.
Example
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);
pub fn with_nanosecond(&self, nano: u32) -> Option<NaiveDateTime>
[src]
pub 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.
Example
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 Type<MySql> for NaiveDateTime
[src]
impl Type<MySql> for NaiveDateTime
[src]pub fn type_info() -> MySqlTypeInfo
[src]
pub fn type_info() -> MySqlTypeInfo
[src]Returns the canonical SQL type for this Rust type. Read more
impl Type<Postgres> for NaiveDateTime
[src]
impl Type<Postgres> for NaiveDateTime
[src]pub fn type_info() -> PgTypeInfo
[src]
pub fn type_info() -> PgTypeInfo
[src]Returns the canonical SQL type for this Rust type. Read more
impl Type<Sqlite> for NaiveDateTime
[src]
impl Type<Sqlite> for NaiveDateTime
[src]pub fn type_info() -> SqliteTypeInfo
[src]
pub fn type_info() -> SqliteTypeInfo
[src]Returns the canonical SQL type for this Rust type. Read more
pub fn compatible(ty: &SqliteTypeInfo) -> bool
[src]
pub fn compatible(ty: &SqliteTypeInfo) -> bool
[src]Determines if this Rust type is compatible with the given SQL type. Read more
impl Copy for NaiveDateTime
[src]
impl Eq for NaiveDateTime
[src]
impl StructuralEq for NaiveDateTime
[src]
impl StructuralPartialEq for NaiveDateTime
[src]
Auto Trait Implementations
impl RefUnwindSafe for NaiveDateTime
impl Send for NaiveDateTime
impl Sync for NaiveDateTime
impl Unpin for NaiveDateTime
impl UnwindSafe for NaiveDateTime
Blanket Implementations
impl<T> BorrowMut<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]
pub fn borrow_mut(&mut self) -> &mut T
[src]Mutably borrows from an owned value. Read more
impl<Q, K> Equivalent<K> for Q where
K: Borrow<Q> + ?Sized,
Q: Eq + ?Sized,
[src]
impl<Q, K> Equivalent<K> for Q where
K: Borrow<Q> + ?Sized,
Q: Eq + ?Sized,
[src]pub fn equivalent(&self, key: &K) -> bool
[src]
pub fn equivalent(&self, key: &K) -> bool
[src]Compare self to key
and return true
if they are equal.
impl<T> FmtForward for T
impl<T> FmtForward for T
fn fmt_binary(self) -> FmtBinary<Self> where
Self: Binary,
fn fmt_binary(self) -> FmtBinary<Self> where
Self: Binary,
Causes self
to use its Binary
implementation when Debug
-formatted.
fn fmt_display(self) -> FmtDisplay<Self> where
Self: Display,
fn fmt_display(self) -> FmtDisplay<Self> where
Self: Display,
Causes self
to use its Display
implementation when
Debug
-formatted. Read more
fn fmt_lower_exp(self) -> FmtLowerExp<Self> where
Self: LowerExp,
fn fmt_lower_exp(self) -> FmtLowerExp<Self> where
Self: LowerExp,
Causes self
to use its LowerExp
implementation when
Debug
-formatted. Read more
fn fmt_lower_hex(self) -> FmtLowerHex<Self> where
Self: LowerHex,
fn fmt_lower_hex(self) -> FmtLowerHex<Self> where
Self: LowerHex,
Causes self
to use its LowerHex
implementation when
Debug
-formatted. Read more
fn fmt_octal(self) -> FmtOctal<Self> where
Self: Octal,
fn fmt_octal(self) -> FmtOctal<Self> where
Self: Octal,
Causes self
to use its Octal
implementation when Debug
-formatted.
fn fmt_pointer(self) -> FmtPointer<Self> where
Self: Pointer,
fn fmt_pointer(self) -> FmtPointer<Self> where
Self: Pointer,
Causes self
to use its Pointer
implementation when
Debug
-formatted. Read more
fn fmt_upper_exp(self) -> FmtUpperExp<Self> where
Self: UpperExp,
fn fmt_upper_exp(self) -> FmtUpperExp<Self> where
Self: UpperExp,
Causes self
to use its UpperExp
implementation when
Debug
-formatted. Read more
fn fmt_upper_hex(self) -> FmtUpperHex<Self> where
Self: UpperHex,
fn fmt_upper_hex(self) -> FmtUpperHex<Self> where
Self: UpperHex,
Causes self
to use its UpperHex
implementation when
Debug
-formatted. Read more
impl<T> Pipe for T where
T: ?Sized,
impl<T> Pipe for T where
T: ?Sized,
fn pipe<R>(self, func: impl FnOnce(Self) -> R) -> R
fn pipe<R>(self, func: impl FnOnce(Self) -> R) -> R
Pipes by value. This is generally the method you want to use. Read more
fn pipe_ref<'a, R>(&'a self, func: impl FnOnce(&'a Self) -> R) -> R where
R: 'a,
fn pipe_ref<'a, R>(&'a self, func: impl FnOnce(&'a Self) -> R) -> R where
R: 'a,
Borrows self
and passes that borrow into the pipe function. Read more
fn pipe_ref_mut<'a, R>(&'a mut self, func: impl FnOnce(&'a mut Self) -> R) -> R where
R: 'a,
fn pipe_ref_mut<'a, R>(&'a mut self, func: impl FnOnce(&'a mut Self) -> R) -> R where
R: 'a,
Mutably borrows self
and passes that borrow into the pipe function. Read more
fn pipe_borrow<'a, B, R>(&'a self, func: impl FnOnce(&'a B) -> R) -> R where
Self: Borrow<B>,
R: 'a,
B: 'a + ?Sized,
fn pipe_borrow<'a, B, R>(&'a self, func: impl FnOnce(&'a B) -> R) -> R where
Self: Borrow<B>,
R: 'a,
B: 'a + ?Sized,
Borrows self
, then passes self.borrow()
into the pipe function. Read more
fn pipe_borrow_mut<'a, B, R>(
&'a mut self,
func: impl FnOnce(&'a mut B) -> R
) -> R where
Self: BorrowMut<B>,
R: 'a,
B: 'a + ?Sized,
fn pipe_borrow_mut<'a, B, R>(
&'a mut self,
func: impl FnOnce(&'a mut B) -> R
) -> R where
Self: BorrowMut<B>,
R: 'a,
B: 'a + ?Sized,
Mutably borrows self
, then passes self.borrow_mut()
into the pipe
function. Read more
fn pipe_as_ref<'a, U, R>(&'a self, func: impl FnOnce(&'a U) -> R) -> R where
Self: AsRef<U>,
U: 'a + ?Sized,
R: 'a,
fn pipe_as_ref<'a, U, R>(&'a self, func: impl FnOnce(&'a U) -> R) -> R where
Self: AsRef<U>,
U: 'a + ?Sized,
R: 'a,
Borrows self
, then passes self.as_ref()
into the pipe function.
fn pipe_as_mut<'a, U, R>(&'a mut self, func: impl FnOnce(&'a mut U) -> R) -> R where
Self: AsMut<U>,
U: 'a + ?Sized,
R: 'a,
fn pipe_as_mut<'a, U, R>(&'a mut self, func: impl FnOnce(&'a mut U) -> R) -> R where
Self: AsMut<U>,
U: 'a + ?Sized,
R: 'a,
Mutably borrows self
, then passes self.as_mut()
into the pipe
function. Read more
fn pipe_deref<'a, T, R>(&'a self, func: impl FnOnce(&'a T) -> R) -> R where
Self: Deref<Target = T>,
T: 'a + ?Sized,
R: 'a,
fn pipe_deref<'a, T, R>(&'a self, func: impl FnOnce(&'a T) -> R) -> R where
Self: Deref<Target = T>,
T: 'a + ?Sized,
R: 'a,
Borrows self
, then passes self.deref()
into the pipe function.
impl<T> PipeAsRef for T
impl<T> PipeAsRef for T
fn pipe_as_ref<'a, T, R>(&'a self, func: impl FnOnce(&'a T) -> R) -> R where
Self: AsRef<T>,
T: 'a,
R: 'a,
fn pipe_as_ref<'a, T, R>(&'a self, func: impl FnOnce(&'a T) -> R) -> R where
Self: AsRef<T>,
T: 'a,
R: 'a,
Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more
fn pipe_as_mut<'a, T, R>(&'a mut self, func: impl FnOnce(&'a mut T) -> R) -> R where
Self: AsMut<T>,
T: 'a,
R: 'a,
fn pipe_as_mut<'a, T, R>(&'a mut self, func: impl FnOnce(&'a mut T) -> R) -> R where
Self: AsMut<T>,
T: 'a,
R: 'a,
Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more
impl<T> PipeBorrow for T
impl<T> PipeBorrow for T
fn pipe_borrow<'a, T, R>(&'a self, func: impl FnOnce(&'a T) -> R) -> R where
Self: Borrow<T>,
T: 'a,
R: 'a,
fn pipe_borrow<'a, T, R>(&'a self, func: impl FnOnce(&'a T) -> R) -> R where
Self: Borrow<T>,
T: 'a,
R: 'a,
Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more
fn pipe_borrow_mut<'a, T, R>(
&'a mut self,
func: impl FnOnce(&'a mut T) -> R
) -> R where
Self: BorrowMut<T>,
T: 'a,
R: 'a,
fn pipe_borrow_mut<'a, T, R>(
&'a mut self,
func: impl FnOnce(&'a mut T) -> R
) -> R where
Self: BorrowMut<T>,
T: 'a,
R: 'a,
Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more
impl<T> PipeDeref for T
impl<T> PipeDeref for T
fn pipe_deref<'a, R>(&'a self, func: impl FnOnce(&'a Self::Target) -> R) -> R where
Self: Deref,
R: 'a,
fn pipe_deref<'a, R>(&'a self, func: impl FnOnce(&'a Self::Target) -> R) -> R where
Self: Deref,
R: 'a,
Pipes a dereference into a function that cannot normally be called in suffix position. Read more
fn pipe_deref_mut<'a, R>(
&'a mut self,
func: impl FnOnce(&'a mut Self::Target) -> R
) -> R where
Self: DerefMut,
R: 'a,
fn pipe_deref_mut<'a, R>(
&'a mut self,
func: impl FnOnce(&'a mut Self::Target) -> R
) -> R where
Self: DerefMut,
R: 'a,
Pipes a mutable dereference into a function that cannot normally be called in suffix position. Read more
impl<T> PipeRef for T
impl<T> PipeRef for T
impl<T> Same<T> for T
impl<T> Same<T> for T
type Output = T
type Output = T
Should always be Self
impl<T> SubsecRound for T where
T: Add<Duration, Output = T> + Sub<Duration, Output = T> + Timelike,
[src]
impl<T> SubsecRound for T where
T: Add<Duration, Output = T> + Sub<Duration, Output = T> + Timelike,
[src]pub fn round_subsecs(self, digits: u16) -> T
[src]
pub fn round_subsecs(self, digits: u16) -> T
[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). Read more
pub fn trunc_subsecs(self, digits: u16) -> T
[src]
pub fn trunc_subsecs(self, digits: u16) -> T
[src]Return a copy truncated to the specified number of subsecond digits. With 9 or more digits, self is returned unmodified. Read more
impl<T> Tap for T
impl<T> Tap for T
fn tap_borrow<B>(self, func: impl FnOnce(&B)) -> Self where
Self: Borrow<B>,
B: ?Sized,
fn tap_borrow<B>(self, func: impl FnOnce(&B)) -> Self where
Self: Borrow<B>,
B: ?Sized,
Immutable access to the Borrow<B>
of a value. Read more
fn tap_borrow_mut<B>(self, func: impl FnOnce(&mut B)) -> Self where
Self: BorrowMut<B>,
B: ?Sized,
fn tap_borrow_mut<B>(self, func: impl FnOnce(&mut B)) -> Self where
Self: BorrowMut<B>,
B: ?Sized,
Mutable access to the BorrowMut<B>
of a value. Read more
fn tap_ref<R>(self, func: impl FnOnce(&R)) -> Self where
Self: AsRef<R>,
R: ?Sized,
fn tap_ref<R>(self, func: impl FnOnce(&R)) -> Self where
Self: AsRef<R>,
R: ?Sized,
Immutable access to the AsRef<R>
view of a value. Read more
fn tap_ref_mut<R>(self, func: impl FnOnce(&mut R)) -> Self where
Self: AsMut<R>,
R: ?Sized,
fn tap_ref_mut<R>(self, func: impl FnOnce(&mut R)) -> Self where
Self: AsMut<R>,
R: ?Sized,
Mutable access to the AsMut<R>
view of a value. Read more
fn tap_deref<T>(self, func: impl FnOnce(&T)) -> Self where
Self: Deref<Target = T>,
T: ?Sized,
fn tap_deref<T>(self, func: impl FnOnce(&T)) -> Self where
Self: Deref<Target = T>,
T: ?Sized,
Immutable access to the Deref::Target
of a value. Read more
fn tap_deref_mut<T>(self, func: impl FnOnce(&mut T)) -> Self where
Self: DerefMut<Target = T> + Deref,
T: ?Sized,
fn tap_deref_mut<T>(self, func: impl FnOnce(&mut T)) -> Self where
Self: DerefMut<Target = T> + Deref,
T: ?Sized,
Mutable access to the Deref::Target
of a value. Read more
fn tap_dbg(self, func: impl FnOnce(&Self)) -> Self
fn tap_dbg(self, func: impl FnOnce(&Self)) -> Self
Calls .tap()
only in debug builds, and is erased in release builds.
fn tap_mut_dbg(self, func: impl FnOnce(&mut Self)) -> Self
fn tap_mut_dbg(self, func: impl FnOnce(&mut Self)) -> Self
Calls .tap_mut()
only in debug builds, and is erased in release
builds. Read more
fn tap_borrow_dbg<B>(self, func: impl FnOnce(&B)) -> Self where
Self: Borrow<B>,
B: ?Sized,
fn tap_borrow_dbg<B>(self, func: impl FnOnce(&B)) -> Self where
Self: Borrow<B>,
B: ?Sized,
Calls .tap_borrow()
only in debug builds, and is erased in release
builds. Read more
fn tap_borrow_mut_dbg<B>(self, func: impl FnOnce(&mut B)) -> Self where
Self: BorrowMut<B>,
B: ?Sized,
fn tap_borrow_mut_dbg<B>(self, func: impl FnOnce(&mut B)) -> Self where
Self: BorrowMut<B>,
B: ?Sized,
Calls .tap_borrow_mut()
only in debug builds, and is erased in release
builds. Read more
fn tap_ref_dbg<R>(self, func: impl FnOnce(&R)) -> Self where
Self: AsRef<R>,
R: ?Sized,
fn tap_ref_dbg<R>(self, func: impl FnOnce(&R)) -> Self where
Self: AsRef<R>,
R: ?Sized,
Calls .tap_ref()
only in debug builds, and is erased in release
builds. Read more
fn tap_ref_mut_dbg<R>(self, func: impl FnOnce(&mut R)) -> Self where
Self: AsMut<R>,
R: ?Sized,
fn tap_ref_mut_dbg<R>(self, func: impl FnOnce(&mut R)) -> Self where
Self: AsMut<R>,
R: ?Sized,
Calls .tap_ref_mut()
only in debug builds, and is erased in release
builds. Read more
impl<T> Tap for T
impl<T> Tap for T
fn tap<F, R>(self, func: F) -> Self where
F: FnOnce(&Self) -> R,
fn tap<F, R>(self, func: F) -> Self where
F: FnOnce(&Self) -> R,
Provides immutable access for inspection. Read more
fn tap_dbg<F, R>(self, func: F) -> Self where
F: FnOnce(&Self) -> R,
fn tap_dbg<F, R>(self, func: F) -> Self where
F: FnOnce(&Self) -> R,
Calls tap
in debug builds, and does nothing in release builds.
fn tap_mut<F, R>(self, func: F) -> Self where
F: FnOnce(&mut Self) -> R,
fn tap_mut<F, R>(self, func: F) -> Self where
F: FnOnce(&mut Self) -> R,
Provides mutable access for modification. Read more
fn tap_mut_dbg<F, R>(self, func: F) -> Self where
F: FnOnce(&mut Self) -> R,
fn tap_mut_dbg<F, R>(self, func: F) -> Self where
F: FnOnce(&mut Self) -> R,
Calls tap_mut
in debug builds, and does nothing in release builds.
impl<T, U> TapAsRef<U> for T where
U: ?Sized,
impl<T, U> TapAsRef<U> for T where
U: ?Sized,
fn tap_ref<F, R>(self, func: F) -> Self where
Self: AsRef<T>,
F: FnOnce(&T) -> R,
fn tap_ref<F, R>(self, func: F) -> Self where
Self: AsRef<T>,
F: FnOnce(&T) -> R,
Provides immutable access to the reference for inspection.
fn tap_ref_dbg<F, R>(self, func: F) -> Self where
Self: AsRef<T>,
F: FnOnce(&T) -> R,
fn tap_ref_dbg<F, R>(self, func: F) -> Self where
Self: AsRef<T>,
F: FnOnce(&T) -> R,
Calls tap_ref
in debug builds, and does nothing in release builds.
fn tap_ref_mut<F, R>(self, func: F) -> Self where
Self: AsMut<T>,
F: FnOnce(&mut T) -> R,
fn tap_ref_mut<F, R>(self, func: F) -> Self where
Self: AsMut<T>,
F: FnOnce(&mut T) -> R,
Provides mutable access to the reference for modification.
fn tap_ref_mut_dbg<F, R>(self, func: F) -> Self where
Self: AsMut<T>,
F: FnOnce(&mut T) -> R,
fn tap_ref_mut_dbg<F, R>(self, func: F) -> Self where
Self: AsMut<T>,
F: FnOnce(&mut T) -> R,
Calls tap_ref_mut
in debug builds, and does nothing in release builds.
impl<T, U> TapBorrow<U> for T where
U: ?Sized,
impl<T, U> TapBorrow<U> for T where
U: ?Sized,
fn tap_borrow<F, R>(self, func: F) -> Self where
Self: Borrow<T>,
F: FnOnce(&T) -> R,
fn tap_borrow<F, R>(self, func: F) -> Self where
Self: Borrow<T>,
F: FnOnce(&T) -> R,
Provides immutable access to the borrow for inspection. Read more
fn tap_borrow_dbg<F, R>(self, func: F) -> Self where
Self: Borrow<T>,
F: FnOnce(&T) -> R,
fn tap_borrow_dbg<F, R>(self, func: F) -> Self where
Self: Borrow<T>,
F: FnOnce(&T) -> R,
Calls tap_borrow
in debug builds, and does nothing in release builds.
fn tap_borrow_mut<F, R>(self, func: F) -> Self where
Self: BorrowMut<T>,
F: FnOnce(&mut T) -> R,
fn tap_borrow_mut<F, R>(self, func: F) -> Self where
Self: BorrowMut<T>,
F: FnOnce(&mut T) -> R,
Provides mutable access to the borrow for modification.
fn tap_borrow_mut_dbg<F, R>(self, func: F) -> Self where
Self: BorrowMut<T>,
F: FnOnce(&mut T) -> R,
fn tap_borrow_mut_dbg<F, R>(self, func: F) -> Self where
Self: BorrowMut<T>,
F: FnOnce(&mut T) -> R,
Calls tap_borrow_mut
in debug builds, and does nothing in release
builds. Read more
impl<T> TapDeref for T
impl<T> TapDeref for T
fn tap_deref<F, R>(self, func: F) -> Self where
Self: Deref,
F: FnOnce(&Self::Target) -> R,
fn tap_deref<F, R>(self, func: F) -> Self where
Self: Deref,
F: FnOnce(&Self::Target) -> R,
Immutably dereferences self
for inspection.
fn tap_deref_dbg<F, R>(self, func: F) -> Self where
Self: Deref,
F: FnOnce(&Self::Target) -> R,
fn tap_deref_dbg<F, R>(self, func: F) -> Self where
Self: Deref,
F: FnOnce(&Self::Target) -> R,
Calls tap_deref
in debug builds, and does nothing in release builds.
fn tap_deref_mut<F, R>(self, func: F) -> Self where
Self: DerefMut,
F: FnOnce(&mut Self::Target) -> R,
fn tap_deref_mut<F, R>(self, func: F) -> Self where
Self: DerefMut,
F: FnOnce(&mut Self::Target) -> R,
Mutably dereferences self
for modification.
fn tap_deref_mut_dbg<F, R>(self, func: F) -> Self where
Self: DerefMut,
F: FnOnce(&mut Self::Target) -> R,
fn tap_deref_mut_dbg<F, R>(self, func: F) -> Self where
Self: DerefMut,
F: FnOnce(&mut Self::Target) -> R,
Calls tap_deref_mut
in debug builds, and does nothing in release
builds. Read more
impl<T> ToOwned for T where
T: Clone,
[src]
impl<T> ToOwned for T where
T: Clone,
[src]type Owned = T
type Owned = T
The resulting type after obtaining ownership.
pub fn to_owned(&self) -> T
[src]
pub fn to_owned(&self) -> T
[src]Creates owned data from borrowed data, usually by cloning. Read more
pub fn clone_into(&self, target: &mut T)
[src]
pub fn clone_into(&self, target: &mut T)
[src]đŹ This is a nightly-only experimental API. (toowned_clone_into
)
recently added
Uses borrowed data to replace owned data, usually by cloning. Read more
impl<V, T> VZip<V> for T where
V: MultiLane<T>,
impl<V, T> VZip<V> for T where
V: MultiLane<T>,