Struct TimeOfDay 

pub struct TimeOfDay(/* private fields */);

A time of day, nanosecond precision.

Implementations

impl TimeOfDay

pub const MIDNIGHT: TimeOfDay

00:00:00.000000000.

pub const NOON: TimeOfDay

12:00:00.000000000.

pub const MAX: TimeOfDay

23:59:59.999999999.

pub const fn from_nanos_since_midnight(nanos: u64) -> Result<TimeOfDay>

Build from nanoseconds since midnight; validates the day bound.

pub fn from_hms(hour: u32, minute: u32, second: u32) -> Result<TimeOfDay>

Build from hour/minute/second.

pub fn from_hms_milli( hour: u32, minute: u32, second: u32, milli: u32, ) -> Result<TimeOfDay>

Build from hour/minute/second/millisecond.

pub fn from_hms_micro( hour: u32, minute: u32, second: u32, micro: u32, ) -> Result<TimeOfDay>

Build from hour/minute/second/microsecond.

pub fn from_hms_nano( hour: u32, minute: u32, second: u32, nano: u32, ) -> Result<TimeOfDay>

Build from hour/minute/second/nanosecond.

Examples found in repository

examples/bench.rs (line 29)

fn main() {
    let d = Date::from_ymd(2024, 6, 15).unwrap();
    let t = TimeOfDay::from_hms_nano(8, 30, 0, 123_456_789).unwrap();
    let dt = CivilDateTime::new(d, t);
    let ticks = Ticks::from_rfc3339("2024-06-15T08:30:00.123456789Z").unwrap();
    let span = Duration::from_nanos(123_456_789_123);
    let mut out = [0u8; 64];

    bench("date civil projection (parts)", 1_000_000, || {
        black_box(black_box(d).parts());
    });
    bench("date weekday", 1_000_000, || {
        black_box(black_box(d).weekday());
    });
    bench("ticks -> civil utc", 1_000_000, || {
        let _ = black_box(black_box(ticks).to_civil_utc());
    });
    bench("ticks -> unix seconds", 1_000_000, || {
        let _ = black_box(black_box(ticks).to_unix_seconds());
    });
    bench("civil -> ticks utc", 1_000_000, || {
        let _ = black_box(black_box(dt).to_ticks_utc());
    });
    bench("ticks checked_add duration", 1_000_000, || {
        let _ = black_box(black_box(ticks).checked_add(black_box(span)));
    });
    bench("parse RFC 3339", 200_000, || {
        let _ = black_box(Ticks::from_rfc3339("2024-06-15T08:30:00.123456789Z"));
    });
    bench("format RFC 3339 (buffer)", 200_000, || {
        let _ = black_box(black_box(ticks).write_rfc3339(&mut out, tzcraft::FractionDigits::Auto));
    });
    bench("format strftime (buffer)", 200_000, || {
        let _ = black_box(black_box(ticks).write_format("%Y-%m-%d %H:%M:%S%.f", &mut out));
    });
    bench("parse ISO 8601 duration", 200_000, || {
        let _ = black_box(Duration::from_iso8601("P1DT2H3M4.5S"));
    });
}

pub const fn nanos_since_midnight(self) -> u64

Nanoseconds since midnight.

pub const fn num_seconds_from_midnight(self) -> u32

Whole seconds since midnight (chrono’s Timelike::num_seconds_from_midnight).

pub fn with_hour(self, hour: u32) -> Result<TimeOfDay>

Replace the hour.

pub fn with_minute(self, minute: u32) -> Result<TimeOfDay>

Replace the minute.

pub fn with_second(self, second: u32) -> Result<TimeOfDay>

Replace the second.

pub fn with_nanosecond(self, nano: u32) -> Result<TimeOfDay>

Replace the nanosecond within the second.

pub const fn hour(self) -> u32

Hour (0..24).

pub const fn minute(self) -> u32

Minute (0..60).

pub const fn second(self) -> u32

Second (0..60).

pub const fn nanosecond(self) -> u32

Nanosecond within the second (0..1e9).

pub const fn millisecond(self) -> u32

Millisecond within the second (0..1000).

pub const fn microsecond(self) -> u32

Microsecond within the second (0..1e6).

pub const fn parts(self) -> (u32, u32, u32, u32)

(hour, minute, second, nanosecond).

pub fn checked_add(self, delta: Duration) -> Result<TimeOfDay>

Checked addition that must stay inside the day.

pub fn checked_sub(self, delta: Duration) -> Result<TimeOfDay>

Checked subtraction that must stay inside the day.

pub fn checked_add_signed(self, rhs: Duration) -> Result<TimeOfDay>

Alias for TimeOfDay::checked_add (chrono-compatible name).

pub fn checked_sub_signed(self, rhs: Duration) -> Result<TimeOfDay>

Alias for TimeOfDay::checked_sub (chrono-compatible name).

pub fn overflowing_add(self, delta: Duration) -> (TimeOfDay, i64)

Addition with a whole-day carry instead of an error.

Returns (time_in_day, whole_days_carried). The arithmetic saturates and the carry clamps at i64 bounds for absurdly large durations, so no input can overflow or panic.

pub fn signed_duration_since(self, earlier: TimeOfDay) -> Duration

Signed difference self - earlier (chrono-compatible name).

pub fn duration_since(self, earlier: TimeOfDay) -> Duration

Signed difference self - earlier.

pub fn to_iso(self) -> String

Available on crate feature alloc only.

Strict ISO 8601 rendering (HH:MM:SS[.fffffffff]).

This method allocates. The allocator-free equivalent is TimeOfDay::write_iso.

pub fn write_iso(self, out: &mut [u8]) -> Result<usize>

Strict ISO 8601 rendering into a caller-owned buffer (allocator-free).

Returns the number of bytes written; a 16-byte buffer is always large enough.

pub fn from_iso(s: &str) -> Result<TimeOfDay>

Parse a strict ISO 8601 time of day (HH:MM:SS, optional fraction).

pub fn format(self, fmt: &str) -> Result<String>

Available on crate feature alloc only.

strftime-style rendering, e.g. t.format("%H:%M:%S%.f").

The %-directive set is documented on crate::Ticks::format.

This method allocates. The allocator-free equivalent is TimeOfDay::write_format.

pub fn write_format(self, fmt: &str, out: &mut [u8]) -> Result<usize>

strftime-style rendering into a caller-owned buffer (allocator-free).

pub fn parse_from_str(s: &str, fmt: &str) -> Result<TimeOfDay>

Parse with a strftime-style format string (chrono’s NaiveTime::parse_from_str).

Trait Implementations

impl Clone for TimeOfDay

fn clone(&self) -> TimeOfDay

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for TimeOfDay

impl Debug for TimeOfDay

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

Formats the value using the given formatter.

impl Display for TimeOfDay

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

Formats the value using the given formatter.

impl Eq for TimeOfDay

impl FromStr for TimeOfDay

type Err = Error

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<TimeOfDay>

Parses a string s to return a value of this type.

impl Hash for TimeOfDay

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

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<'de> NsonDeserialize<'de> for TimeOfDay

Available on crate feature serde only.

fn nextdecode_into<D: FormatDecoder<'de>>( dec: &mut D, out: &mut DecodeSlot<Self>, ) -> Result<(), D::Error>

Decode into out.

fn expecting() -> &'static str

Human-readable description of the value this type decodes from.

fn nextdecode<D>( decoder: &mut D, ) -> Result<Self, <D as FormatDecoder<'de>>::Error>

where D: FormatDecoder<'de>,

Decode and return a value.

impl NsonSchema for TimeOfDay

Available on crate feature serde only.

const SCHEMA: TypeSchema = TypeSchema::Str

The compile-time structural description.

impl NsonSerialize for TimeOfDay

Available on crate feature serde only.

fn nextencode<E: FormatEncoder>(&self, enc: &mut E) -> Result<(), E::Error>

Next-encode self into encoder.

impl Ord for TimeOfDay

fn cmp(&self, other: &TimeOfDay) -> 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.

fn clamp_to<R>(self, range: R) -> Self

where Self: Sized, R: ClampBounds<Self>,

🔬This is a nightly-only experimental API. (clamp_to)

Restrict a value to a certain range.

impl PartialEq for TimeOfDay

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

Equality operator ==.

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

Inequality operator !=.

impl PartialOrd for TimeOfDay

fn partial_cmp(&self, other: &TimeOfDay) -> 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 StructuralPartialEq for TimeOfDay