Struct rbatis::TimeUtc[−][src]

pub struct TimeUtc {
    pub inner: NaiveTime,
}

Fields

inner: NaiveTime

Implementations

[src]

impl TimeUtc

[src]

pub fn now() -> TimeUtc

Returns a [DateTime] which corresponds to the current date and time.

[src]

pub fn from_str(arg: &str) -> Result<TimeUtc, Error>

create from str

Methods from Deref<Target = NaiveTime>

[src]

pub fn overflowing_add_signed(&self, rhs: Duration) -> (NaiveTime, i64 )

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

Example

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

[src]

pub fn overflowing_sub_signed(&self, rhs: Duration) -> (NaiveTime, i64 )

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

Example

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

[src]

pub fn format_with_items<'a, I, B>(&self, items: I) -> DelayedFormat where
I: Iterator<Item = B> + Clone,
B: Borrow<Item<'a>>,

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.

Example

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");

[src]

pub fn format(&self, fmt: &'a str) -> DelayedFormat<StrftimeItems<'a>>

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.

Example

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");