Struct greg::calendar::Time

pub struct Time {
    pub h: u8,
    pub m: u8,
    pub s: u8,
}

Time-of-Day

Warning: if you set the fields yourself it is your responsibility to ensure that they are valid! Self::is_valid can be used to conveniently check.

Because this library does not respect leap seconds, the s field may never be 60.

Fields

h: u8

Hours (0..24)

m: u8

Minutes (0..60)

s: u8

Seconds (0..60)

Implementations

impl Time

pub const MIDNIGHT: Self = _

The beginning of the day, 00:00:00

pub const fn hms_checked(h: u8, m: u8, s: u8) -> Self

Construct from hours, minutes and seconds and assert Self::is_valid

 use greg::calendar::Time;
 const INVALID: Time = Time::hms_checked(24, 0, 0);

pub const fn is_valid(self) -> bool

Checks whether fields are in the valid range

Does not allow for a leap second, self.s must be in 0..=59 to be valid.

pub const fn as_seconds(self) -> u32

Seconds since midnight

pub const fn as_span(self) -> Span

Duration since midnight

impl Time

pub const fn try_parse(from: &str) -> Result<Self, ParseError>

Try to parse Time as hh:mm:ss or hh:mm

Does not accept strings with too much or too little 0-padding.

 use greg::calendar::Time;
 assert_eq!(Time::try_parse("00:00:00"), Ok(Time::hms_checked(0, 0, 0)));
 assert_eq!(Time::try_parse("10:15"), Ok(Time::hms_checked(10, 15, 0)));
 assert_eq!(
     Time::try_parse("12:34:56"),
     Ok(Time::hms_checked(12, 34, 56))
 );
 // also implemented via FromStr
 assert_eq!(
     "23:59:59".parse::<Time>(),
     Ok(Time::hms_checked(23, 59, 59))
 );

 use greg::calendar::ParseError;

 assert_eq!(Time::try_parse("2021-01-01"), Err(ParseError::Format));
 assert_eq!(Time::try_parse("24:00:00"), Err(ParseError::Invalid));
 assert_eq!(Time::try_parse("23:1:0"), Err(ParseError::Format));
 // no leap seconds
 assert!("23:59:60".parse::<Time>().is_err());
 // no sub-second precision
 assert!("12:34:56.789".parse::<Time>().is_err());
 assert!("6pm".parse::<Time>().is_err());

pub const fn parse(from: &str) -> Self

Try to parse Time as hh:mm:ss or hh:mm and panic if invalid

 use greg::calendar::Time;
 const NOON_ISH: Time = Time::parse("12:34:56");

 assert_eq!(Time::parse("00:00:00"), Time::MIDNIGHT);
 assert_eq!(Time::parse("10:15"), Time::hms_checked(10, 15, 0));

This is mainly useful in const contexts, since the panic gets caught at compile-time.

 use greg::calendar::Time;
 const MORNING: Time = Time::parse("06;30"); // typo: ';' instead of ':'

Trait Implementations

impl Clone for Time

fn clone(&self) -> Time

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Time

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

Same as Display: hh:mm:ss (i.e. 12:34:56)

impl<'de> Deserialize<'de> for Time

Available on crate feature serde only.

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

Deserialize this value from the given Serde deserializer.

impl Display for Time

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

Formats the Time as hh:mm:ss (i.e. 12:34:56)

impl FromStr for Time

fn from_str(s: &str) -> Result<Self, Self::Err>

Parse hh:mm:ss or hh:mm time

Does not accept strings with too much or too little 0-padding.

 use greg::calendar::Time;
 assert_eq!("00:00:00".parse(), Ok(Time::hms_checked(0, 0, 0)));
 assert_eq!("10:15".parse(), Ok(Time::hms_checked(10, 15, 0)));
 assert_eq!("12:34:56".parse(), Ok(Time::hms_checked(12, 34, 56)));
 assert_eq!("23:59:59".parse(), Ok(Time::hms_checked(23, 59, 59)));

 assert!("2021-01-01".parse::<Time>().is_err());
 assert!("24:00:00".parse::<Time>().is_err());
 assert!("23:1:0".parse::<Time>().is_err());
 // no leap seconds
 assert!("23:59:60".parse::<Time>().is_err());
 // no sub-second precision
 assert!("12:34:56.789".parse::<Time>().is_err());
 assert!("6pm".parse::<Time>().is_err());

type Err = ParseError

The associated error which can be returned from parsing.

impl Hash for Time

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 Ord for Time

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

This method returns an Ordering between self and other.

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

Compares and returns the maximum of two values.

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

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Selfwhere Self: Sized + PartialOrd,

Restrict a value to a certain interval.

impl PartialEq for Time

fn eq(&self, other: &Time) -> 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 !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialOrd for Time

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

Available on crate feature serde only.

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

Serialize this value into the given Serde serializer.

impl Copy for Time

impl Eq for Time

impl StructuralEq for Time

impl StructuralPartialEq for Time