Struct TimeUtc 

pub struct TimeUtc {
    pub inner: NaiveTime,
}

Fields

inner: NaiveTime

Implementations

impl TimeUtc

pub fn now() -> TimeUtc

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

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

create from str

Methods from Deref<Target = NaiveTime>

pub const MIN: NaiveTime

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

Adds given TimeDelta to the current time, and also returns the number of seconds in the integral number of days ignored from the addition.

Example

use chrono::{NaiveTime, TimeDelta};

let from_hms = |h, m, s| NaiveTime::from_hms_opt(h, m, s).unwrap();

assert_eq!(
    from_hms(3, 4, 5).overflowing_add_signed(TimeDelta::try_hours(11).unwrap()),
    (from_hms(14, 4, 5), 0)
);
assert_eq!(
    from_hms(3, 4, 5).overflowing_add_signed(TimeDelta::try_hours(23).unwrap()),
    (from_hms(2, 4, 5), 86_400)
);
assert_eq!(
    from_hms(3, 4, 5).overflowing_add_signed(TimeDelta::try_hours(-7).unwrap()),
    (from_hms(20, 4, 5), -86_400)
);

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

Subtracts given TimeDelta from the current time, and also returns the number of seconds in the integral number of days ignored from the subtraction.

Example

use chrono::{NaiveTime, TimeDelta};

let from_hms = |h, m, s| NaiveTime::from_hms_opt(h, m, s).unwrap();

assert_eq!(
    from_hms(3, 4, 5).overflowing_sub_signed(TimeDelta::try_hours(2).unwrap()),
    (from_hms(1, 4, 5), 0)
);
assert_eq!(
    from_hms(3, 4, 5).overflowing_sub_signed(TimeDelta::try_hours(17).unwrap()),
    (from_hms(10, 4, 5), 86_400)
);
assert_eq!(
    from_hms(3, 4, 5).overflowing_sub_signed(TimeDelta::try_hours(-22).unwrap()),
    (from_hms(1, 4, 5), -86_400)
);

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 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::format::strftime::StrftimeItems;
use chrono::NaiveTime;

let fmt = StrftimeItems::new("%H:%M:%S");
let t = NaiveTime::from_hms_opt(23, 56, 4).unwrap();
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>>

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_opt(23, 56, 4, 12_345_678).unwrap();
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");

Trait Implementations

impl Clone for TimeUtc

fn clone(&self) -> TimeUtc

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for TimeUtc

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

Formats the value using the given formatter.

impl Deref for TimeUtc

type Target = NaiveTime

The resulting type after dereferencing.

fn deref(&self) -> &<TimeUtc as Deref>::Target

Dereferences the value.

impl DerefMut for TimeUtc

fn deref_mut(&mut self) -> &mut <TimeUtc as Deref>::Target

Mutably dereferences the value.

impl<'de> Deserialize<'de> for TimeUtc

fn deserialize<D>( deserializer: D, ) -> Result<TimeUtc, <D as Deserializer<'de>>::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for TimeUtc

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

Formats the value using the given formatter.

impl From<&NaiveTime> for TimeUtc

fn from(arg: &NaiveTime) -> TimeUtc

Converts to this type from the input type.

impl From<NaiveTime> for TimeUtc

fn from(arg: NaiveTime) -> TimeUtc

Converts to this type from the input type.

impl Hash for TimeUtc

fn hash<__H>(&self, state: &mut __H)

where __H: Hasher,

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl Ord for TimeUtc

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

This method returns an Ordering between self and other.

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

where Self: Sized,

Compares and returns the maximum of two values.

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

where Self: Sized,

Compares and returns the minimum of two values.

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

where Self: Sized,

Restrict a value to a certain interval.

impl PartialEq for TimeUtc

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialOrd for TimeUtc

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

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

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

Tests less than (for self and other) and is used by the < operator.

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

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

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

Tests greater than (for self and other) and is used by the > operator.

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

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

impl Serialize for TimeUtc

fn serialize<S>( &self, serializer: S, ) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.

impl Copy for TimeUtc

impl Eq for TimeUtc

impl StructuralPartialEq for TimeUtc