Struct hyper_scripter::script_time::ScriptTime

pub struct ScriptTime<T = ()> { /* fields omitted */ }

可能帶著資料的時間。 如果有資料，代表「這些資料是新的產生，應儲存起來但還未存」 如果沒資料，就視為上次儲存的一個快照，只記得時間就好，因為我們通常不會需要上一次存下的資料

Implementations

impl<T> ScriptTime<T>

pub fn now(data: T) -> Self

pub fn new_or_else<F: FnOnce() -> Self>(
    time: Option<NaiveDateTime>,
    default: F
) -> Self

pub fn new_or(time: Option<NaiveDateTime>, default: Self) -> Self

pub fn new(time: NaiveDateTime) -> Self

pub fn data(&self) -> Option<&T>

pub fn has_changed(&self) -> bool

Methods from Deref<Target = NaiveDateTime>

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

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

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

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

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

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

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

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, B>(&self, items: I) -> DelayedFormat<I> where
    I: Iterator<Item = B> + Clone,
    B: Borrow<Item<'a>>, 

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.

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>>

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<T: Clone> Clone for ScriptTime<T>

fn clone(&self) -> ScriptTime<T>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T: Debug> Debug for ScriptTime<T>

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

Formats the value using the given formatter.

impl<T> Deref for ScriptTime<T>

type Target = NaiveDateTime

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<T> Display for ScriptTime<T>

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

Formats the value using the given formatter.

impl<T> Ord for ScriptTime<T>

fn cmp(&self, other: &Self) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

Restrict a value to a certain interval.

impl<T> PartialEq<ScriptTime<T>> for ScriptTime<T>

fn eq(&self, other: &Self) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<T> PartialOrd<ScriptTime<T>> for ScriptTime<T>

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

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl<T> Eq for ScriptTime<T>