[−][src]Struct datetime_string::common::Hms6ColonString

#[repr(transparent)]pub struct Hms6ColonString(_);

Owned string for a time in %H:%M:%S (hh:mm:ss) format, such as 01:23:45.

This is also an RFC 3339 partial-time string without secfrac part.

This is a fixed length string, and implements Copy trait.

To create a value of this type, use str::parse method or std::convert::TryFrom trait, or convert from &Hms6ColonStr.

Examples

use datetime_string::common::Hms6ColonStr;
use std::convert::TryFrom;

let try_from = Hms6ColonString::try_from("12:34:56")?;

let parse = "12:34:56".parse::<Hms6ColonString>()?;
let parse2: Hms6ColonString = "12:34:56".parse()?;

let to_owned = Hms6ColonStr::from_str("12:34:56")?.to_owned();
let into: Hms6ColonString = Hms6ColonStr::from_str("12:34:56")?.into();

Implementations

`impl Hms6ColonString`[src]

`pub fn from_hms(hour: u8, minute: u8, second: u8) -> Result<Self, Error>`[src]

Creates a new Hms6ColonString from the given time.

Examples

let time = Hms6ColonString::from_hms(12, 34, 56)?;
assert_eq!(time.as_str(), "12:34:56");

assert!(Hms6ColonString::from_hms(0, 0, 61).is_err(), "00:00:61 is invaild time");

`#[must_use]pub fn as_deref(&self) -> &Hms6ColonStr`[src]

Returns a &Hms6ColonStr for the string.

Examples

use datetime_string::common::Hms6ColonStr;
let time = "12:34:56".parse::<Hms6ColonString>()?;

// Usually you don't need to call `as_deref()` explicitly, because
// `Deref<Target = Hms6ColonStr>` trait is implemented.
let _: &Hms6ColonStr = time.as_deref();

`#[must_use]pub fn as_deref_mut(&mut self) -> &mut Hms6ColonStr`[src]

Returns a &mut Hms6ColonStr for the string.

Examples

use datetime_string::common::Hms6ColonStr;
let mut time = "12:34:56".parse::<Hms6ColonString>()?;

// Usually you don't need to call `as_deref_mut()` explicitly, because
// `DerefMut` trait is implemented.
let _: &mut Hms6ColonStr = time.as_deref_mut();

Methods from Deref<Target = Hms6ColonStr>

`pub fn assign(&mut self, v: &Self)`[src]

Assigns the given value.

Examples

let mut buf: [u8; 8] = *b"12:34:56";
let time = Hms6ColonStr::from_bytes_mut(&mut buf[..])?;
assert_eq!(time.as_str(), "12:34:56");

let newtime = Hms6ColonStr::from_str("01:01:01")?;

time.assign(newtime);
assert_eq!(time.as_str(), "01:01:01");
assert_eq!(buf, *b"01:01:01");

`#[must_use]pub fn as_str(&self) -> &str`[src]

Returns a string slice.

Examples

let time = Hms6ColonStr::from_str("12:34:56")?;

assert_eq!(time.as_str(), "12:34:56");

`#[must_use]pub fn as_bytes(&self) -> &[u8]`[src]

Returns a byte slice.

If you want to use indexed access, prefer as_bytes_fixed_len.

Examples

let time = Hms6ColonStr::from_bytes(b"12:34:56")?;

assert_eq!(time.as_bytes(), b"12:34:56");

`#[must_use]pub fn as_bytes_fixed_len(&self) -> &[u8; 8]`[src]

Returns a fixed length byte slice.

Examples

let time = Hms6ColonStr::from_str("12:34:56")?;

let fixed_len: &[u8; 8] = time.as_bytes_fixed_len();
assert_eq!(fixed_len, b"12:34:56");

`#[must_use]pub fn hour_str(&self) -> &str`[src]

Returns the hour as a string slice.

Examples

let time = Hms6ColonStr::from_str("12:34:56")?;

assert_eq!(time.hour_str(), "12");

`#[must_use]pub fn hour_bytes_fixed_len(&self) -> &[u8; 2]`[src]

Returns the hour as a fixed length byte slice.

Examples

let time = Hms6ColonStr::from_str("12:34:56")?;

let hour_fixed_len: &[u8; 2] = time.hour_bytes_fixed_len();
assert_eq!(hour_fixed_len, b"12");

`#[must_use]pub fn hour(&self) -> u8`[src]

Returns the hour as an integer.

Examples

let time = Hms6ColonStr::from_str("12:34:56")?;

assert_eq!(time.hour(), 12);

`#[must_use]pub fn minute_str(&self) -> &str`[src]

Returns the minute as a string slice.

Examples

let time = Hms6ColonStr::from_str("12:34:56")?;

assert_eq!(time.minute_str(), "34");

`#[must_use]pub fn minute_bytes_fixed_len(&self) -> &[u8; 2]`[src]

Returns the minute as a fixed length byte slice.

Examples

let time = Hms6ColonStr::from_str("12:34:56")?;

let minute_fixed_len: &[u8; 2] = time.minute_bytes_fixed_len();
assert_eq!(minute_fixed_len, b"34");

`#[must_use]pub fn minute(&self) -> u8`[src]

Returns the minute as an integer.

Examples

let time = Hms6ColonStr::from_str("12:34:56")?;

assert_eq!(time.minute(), 34);

`#[must_use]pub fn second_str(&self) -> &str`[src]

Returns the second as a string slice.

Examples

let time = Hms6ColonStr::from_str("12:34:56")?;

assert_eq!(time.second_str(), "56");

`#[must_use]pub fn second_bytes_fixed_len(&self) -> &[u8; 2]`[src]

Returns the second as a fixed length byte slice.

Examples

let time = Hms6ColonStr::from_str("12:34:56")?;

let second_fixed_len: &[u8; 2] = time.second_bytes_fixed_len();
assert_eq!(second_fixed_len, b"56");

`#[must_use]pub fn second(&self) -> u8`[src]

Returns the second as an integer.

Examples

let time = Hms6ColonStr::from_str("12:34:56")?;

assert_eq!(time.second(), 56);

`pub fn set_hour(&mut self, hour: u8) -> Result<(), Error>`[src]

Sets the given hour value to the string.

Failures

Fails if the time after modification is invalid.

Examples

let mut buf: [u8; 8] = *b"12:34:56";
let time = Hms6ColonStr::from_bytes_mut(&mut buf[..])?;
assert_eq!(time.as_str(), "12:34:56");

time.set_hour(0)?;
assert_eq!(time.as_str(), "00:34:56");

assert!(time.set_hour(24).is_err(), "24:34:56 is invalid");

`pub fn set_minute(&mut self, minute: u8) -> Result<(), Error>`[src]

Sets the given minute value to the string.

Failures

Fails if the time after modification is invalid.

Examples

let mut buf: [u8; 8] = *b"12:34:56";
let time = Hms6ColonStr::from_bytes_mut(&mut buf[..])?;
assert_eq!(time.as_str(), "12:34:56");

time.set_minute(0)?;
assert_eq!(time.as_str(), "12:00:56");

assert!(time.set_minute(60).is_err(), "24:60:56 is invalid");

`pub fn set_second(&mut self, second: u8) -> Result<(), Error>`[src]

Sets the given second value to the string.

Failures

Fails if the time after modification is invalid.

Examples

let mut buf: [u8; 8] = *b"12:34:56";
let time = Hms6ColonStr::from_bytes_mut(&mut buf[..])?;
assert_eq!(time.as_str(), "12:34:56");

time.set_second(0)?;
assert_eq!(time.as_str(), "12:34:00");

assert!(time.set_second(61).is_err(), "24:34:61 is invalid");

`pub fn set_hour_minute(&mut self, hour: u8, minute: u8) -> Result<(), Error>`[src]

Sets the given hour and minute values to the string.

Failures

Fails if the time after modification is invalid.

Examples

let mut buf: [u8; 8] = *b"12:34:56";
let time = Hms6ColonStr::from_bytes_mut(&mut buf[..])?;
assert_eq!(time.as_str(), "12:34:56");

time.set_hour_minute(21, 10)?;
assert_eq!(time.as_str(), "21:10:56");

assert!(time.set_hour_minute(23, 60).is_err(), "23:60:56 is invalid");

`pub fn set_minute_second(&mut self, minute: u8, second: u8) -> Result<(), Error>`[src]

Sets the given minute and second values to the string.

Failures

Fails if the time after modification is invalid.

Examples

let mut buf: [u8; 8] = *b"12:34:56";
let time = Hms6ColonStr::from_bytes_mut(&mut buf[..])?;
assert_eq!(time.as_str(), "12:34:56");

time.set_minute_second(54, 32)?;
assert_eq!(time.as_str(), "12:54:32");

assert!(time.set_minute_second(60, 59).is_err(), "12:60:59 is invalid");

`pub fn set_time( &mut self, hour: u8, minute: u8, second: u8 ) -> Result<(), Error>`[src]

Sets the given hour, minute, and second values to the string.

Failures

Fails if the time after modification is invalid.

Examples

let mut buf: [u8; 8] = *b"12:34:56";
let time = Hms6ColonStr::from_bytes_mut(&mut buf[..])?;
assert_eq!(time.as_str(), "12:34:56");

time.set_time(23, 12, 1)?;
assert_eq!(time.as_str(), "23:12:01");

assert!(time.set_time(24, 0, 0).is_err(), "24:00:00 is invalid");

`pub fn to_seconds(&self) -> u32`[src]

Retruns the seconds from the start of the day.

Example

let time = Hms6ColonStr::from_str("12:34:56")?;
assert_eq!(time.to_seconds(), 12 * 60 * 60 + 34 * 60 + 56);

let zero = Hms6ColonStr::from_str("00:00:00")?;
assert_eq!(zero.to_seconds(), 0);

let last = Hms6ColonStr::from_str("23:59:59")?;
assert_eq!(last.to_seconds(), 24 * 60 * 60 - 1);

let last_leap = Hms6ColonStr::from_str("23:59:60")?;
assert_eq!(last_leap.to_seconds(), 24 * 60 * 60);