Struct chrono::naive::TsSeconds [−][src]
pub struct TsSeconds(_);
: RustcSerialize will be removed before chrono 1.0, use Serde instead
A DateTime
that can be deserialized from a seconds-based timestamp
Methods from Deref<Target = NaiveDateTime>
pub fn date(&self) -> NaiveDate
[src]
pub fn date(&self) -> NaiveDate
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
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
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
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
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. (If this is a problem, please file an issue to let me know what domain needs nanosecond precision over millenia, I'm curious.)
Example
use chrono::NaiveDate; 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); assert_eq!(dt.timestamp_nanos(), 1_000_000_000_000_000_555);
pub fn timestamp_subsec_millis(&self) -> u32
[src]
pub fn timestamp_subsec_millis(&self) -> u32
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
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
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 format_with_items<'a, I>(&self, items: I) -> DelayedFormat<I> where
I: Iterator<Item = Item<'a>> + Clone,
[src]
pub fn format_with_items<'a, I>(&self, items: I) -> DelayedFormat<I> where
I: Iterator<Item = Item<'a>> + Clone,
Formats the combined date and time with the specified formatting items.
Otherwise it is same to 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<'a>(&self, fmt: &'a str) -> DelayedFormat<StrftimeItems<'a>>
[src]
pub fn format<'a>(&self, fmt: &'a str) -> DelayedFormat<StrftimeItems<'a>>
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 Debug for TsSeconds
[src]
impl Debug for TsSeconds
fn fmt(&self, f: &mut Formatter) -> Result
[src]
fn fmt(&self, f: &mut Formatter) -> Result
Formats the value using the given formatter. Read more
impl From<TsSeconds> for NaiveDateTime
[src]
impl From<TsSeconds> for NaiveDateTime
fn from(obj: TsSeconds) -> NaiveDateTime
[src]
fn from(obj: TsSeconds) -> NaiveDateTime
Pull the internal NaiveDateTime out
impl Deref for TsSeconds
[src]
impl Deref for TsSeconds
type Target = NaiveDateTime
The resulting type after dereferencing.
fn deref(&self) -> &Self::Target
[src]
fn deref(&self) -> &Self::Target
Dereferences the value.
impl Decodable for TsSeconds
[src]
impl Decodable for TsSeconds