[−][src]Struct datetime_string::rfc3339::SecfracStr

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

String slice for a time in RFC 3339 time-secfrac format, such as .7890.

Implementations

`impl SecfracStr`[src]

`pub fn from_str(s: &str) -> Result<&Self, Error>`[src]

Creates a new &SecfracStr from a string slice.

Examples

let secfrac = SecfracStr::from_str(".1234")?;
assert_eq!(secfrac.as_str(), ".1234");

assert!(SecfracStr::from_str(".0").is_ok());
assert!(SecfracStr::from_str(".0000000000").is_ok());
assert!(SecfracStr::from_str(".9999999999").is_ok());

assert!(SecfracStr::from_str("0").is_err(), "A leading period is required");
assert!(SecfracStr::from_str(".").is_err(), "One or more digits are required");

`pub fn from_mut_str(s: &mut str) -> Result<&mut Self, Error>`[src]

Creates a new &mut SecfracStr from a mutable string slice.

Examples

let mut buf = ".1234".to_owned();
let secfrac = SecfracStr::from_mut_str(&mut buf)?;
assert_eq!(secfrac.as_str(), ".1234");

secfrac.digits_mut().fill_with_zero();
assert_eq!(secfrac.as_str(), ".0000");

assert_eq!(buf, ".0000");

`pub fn from_bytes(s: &[u8]) -> Result<&Self, Error>`[src]

Creates a new &SecfracStr from a byte slice.

Examples

let secfrac = SecfracStr::from_bytes(b".1234")?;
assert_eq!(secfrac.as_str(), ".1234");

assert!(SecfracStr::from_bytes(b".0").is_ok());
assert!(SecfracStr::from_bytes(b".0000000000").is_ok());
assert!(SecfracStr::from_bytes(b".9999999999").is_ok());

assert!(SecfracStr::from_bytes(b"0").is_err(), "A leading period is required");
assert!(SecfracStr::from_bytes(b".").is_err(), "One or more digits are required");

`pub fn from_bytes_mut(s: &mut [u8]) -> Result<&mut Self, Error>`[src]

Creates a new &mut SecfracStr from a mutable byte slice.

Examples

let mut buf: [u8; 5] = *b".1234";
let secfrac = SecfracStr::from_bytes_mut(&mut buf)?;
assert_eq!(secfrac.as_str(), ".1234");

secfrac.digits_mut().fill_with_zero();
assert_eq!(secfrac.as_str(), ".0000");

assert_eq!(&buf[..], b".0000");

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

Returns a string slice.

Examples

let secfrac = SecfracStr::from_str(".1234")?;

assert_eq!(secfrac.as_str(), ".1234");

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

Returns a byte slice.

Examples

let secfrac = SecfracStr::from_str(".1234")?;

assert_eq!(secfrac.as_str(), ".1234");

`#[must_use]pub fn digits(&self) -> &SecfracDigitsStr`[src]

Returns the digits.

Examples

use datetime_string::common::SecfracDigitsStr;

let secfrac = SecfracStr::from_str(".1234")?;
assert_eq!(secfrac.digits().as_str(), "1234");

let secfrac2 = SecfracStr::from_str(".012340")?;
assert_eq!(secfrac2.digits().as_str(), "012340");

`#[must_use]pub fn digits_mut(&mut self) -> &mut SecfracDigitsStr`[src]

Returns the digits as a mutable reference.

Examples

use datetime_string::common::SecfracDigitsStr;

let mut buf = ".1234".to_owned();
let secfrac = SecfracStr::from_mut_str(&mut buf)?;
let digits = secfrac.digits_mut();
assert_eq!(digits.as_str(), "1234");

digits.fill_with_zero();
assert_eq!(digits.as_str(), "0000");
assert_eq!(secfrac.as_str(), ".0000");
assert_eq!(buf, ".0000");

`#[must_use]pub fn milliseconds_secfrac(&self) -> Option<&SecfracStr>`[src]

Returns a milliseconds precision secfrac if there are enough digits.

Examples

let not_precise = SecfracStr::from_str(".1")?;
assert_eq!(not_precise.milliseconds_secfrac(), None);

let expected = SecfracStr::from_str(".012")?;
assert_eq!(expected.milliseconds_secfrac(), Some(expected));

let more_precise = SecfracStr::from_str(".012345678901")?;
assert_eq!(more_precise.milliseconds_secfrac(), Some(expected));

`#[must_use]pub fn microseconds_secfrac(&self) -> Option<&SecfracStr>`[src]

Returns a microseconds precision secfrac if there are enough digits.

Examples

let not_precise = SecfracStr::from_str(".1234")?;
assert_eq!(not_precise.microseconds_secfrac(), None);

let expected = SecfracStr::from_str(".012345")?;
assert_eq!(expected.microseconds_secfrac(), Some(expected));

let more_precise = SecfracStr::from_str(".012345678901")?;
assert_eq!(more_precise.microseconds_secfrac(), Some(expected));

`#[must_use]pub fn nanoseconds_secfrac(&self) -> Option<&SecfracStr>`[src]

Returns a nanoseconds precision secfrac if there are enough digits.

Examples

let not_precise = SecfracStr::from_str(".1234")?;
assert_eq!(not_precise.nanoseconds_secfrac(), None);

let expected = SecfracStr::from_str(".012345678")?;
assert_eq!(expected.nanoseconds_secfrac(), Some(expected));

let more_precise = SecfracStr::from_str(".012345678901")?;
assert_eq!(more_precise.nanoseconds_secfrac(), Some(expected));