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

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

String slice for digits of fractions of a second.

Available when alloc feature is enabled.

Note that values of this type cannot be not empty string.

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

Examples

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

let try_from = SecfracDigitsString::try_from("1234")?;

let parse = "1234".parse::<SecfracDigitsString>()?;
let parse2: SecfracDigitsString = "1234".parse()?;

let to_owned = SecfracDigitsStr::from_str("1234")?.to_owned();
let into: SecfracDigitsString = SecfracDigitsStr::from_str("1234")?.into();

Implementations

`impl SecfracDigitsString`[src]

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

Returns a &SecfracDigitsStr for the string.

Examples

use datetime_string::common::SecfracDigitsStr;

let secfrac = "1234".parse::<SecfracDigitsString>()?;

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

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

Returns a &mut SecfracDigitsStr for the string.

Examples

use datetime_string::common::SecfracDigitsStr;

let mut secfrac = "1234".parse::<SecfracDigitsString>()?;

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

Methods from Deref<Target = SecfracDigitsStr>

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

Returns a string slice.

Examples

let secfrac = SecfracDigitsStr::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 = SecfracDigitsStr::from_str("1234")?;

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

`#[must_use]pub fn milliseconds(&self) -> u16`[src]

Retruns a milliseconds value in integer.

Examples

let not_precise = SecfracDigitsStr::from_str("1")?;
assert_eq!(not_precise.milliseconds(), 100);

let precise = SecfracDigitsStr::from_str("012")?;
assert_eq!(precise.milliseconds(), 12);

let more_precise = SecfracDigitsStr::from_str("369999")?;
assert_eq!(more_precise.milliseconds(), 369);

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

Returns a milliseconds precision substring if there are enough digits.

Examples

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

let precise = SecfracDigitsStr::from_str("012")?;
assert_eq!(precise.milliseconds_digits().unwrap(), "012");

let more_precise = SecfracDigitsStr::from_str("012345678901")?;
assert_eq!(more_precise.milliseconds_digits().unwrap(), "012");

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

Returns a milliseconds precision substring if there are enough digits.

Examples

let mut buf = "012345678901".to_owned();
let digits = SecfracDigitsStr::from_mut_str(&mut buf)?;
assert_eq!(digits.as_str(), "012345678901");

digits.milliseconds_digits_mut().unwrap().fill_with_zero();
assert_eq!(digits.as_str(), "000345678901");

`#[must_use]pub fn milliseconds_bytes_fixed_len(&self) -> Option<&[u8; 3]>`[src]

Returns a milliseconds digits as a fixed bytes slice, if there are enough digits.

Examples

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

let precise = SecfracDigitsStr::from_str("012")?;
assert_eq!(precise.milliseconds_bytes_fixed_len(), Some(b"012"));

let more_precise = SecfracDigitsStr::from_str("012345678901")?;
assert_eq!(more_precise.milliseconds_bytes_fixed_len(), Some(b"012"));

`#[must_use]pub fn microseconds(&self) -> u32`[src]

Retruns a microseconds value in integer.

Examples

let not_precise = SecfracDigitsStr::from_str("1")?;
assert_eq!(not_precise.microseconds(), 100_000);

let precise = SecfracDigitsStr::from_str("012345")?;
assert_eq!(precise.microseconds(), 012_345);

let more_precise = SecfracDigitsStr::from_str("123456999")?;
assert_eq!(more_precise.microseconds(), 123_456);

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

Returns a microseconds precision substring if there are enough digits.

Examples

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

let precise = SecfracDigitsStr::from_str("012345")?;
assert_eq!(precise.microseconds_digits().unwrap(), "012345");

let more_precise = SecfracDigitsStr::from_str("012345678901")?;
assert_eq!(more_precise.microseconds_digits().unwrap(), "012345");

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

Returns a microseconds precision substring if there are enough digits.

Examples

let mut buf = "012345678901".to_owned();
let digits = SecfracDigitsStr::from_mut_str(&mut buf)?;
assert_eq!(digits.as_str(), "012345678901");

digits.microseconds_digits_mut().unwrap().fill_with_zero();
assert_eq!(digits.as_str(), "000000678901");

`#[must_use]pub fn microseconds_bytes_fixed_len(&self) -> Option<&[u8; 6]>`[src]

Returns a microseconds digits as a fixed bytes slice, if there are enough digits.

Examples

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

let precise = SecfracDigitsStr::from_str("012345")?;
assert_eq!(precise.microseconds_bytes_fixed_len(), Some(b"012345"));

let more_precise = SecfracDigitsStr::from_str("012345678901")?;
assert_eq!(more_precise.microseconds_bytes_fixed_len(), Some(b"012345"));

`#[must_use]pub fn nanoseconds(&self) -> u32`[src]

Retruns a nanoseconds value in integer.

Examples

let not_precise = SecfracDigitsStr::from_str("1")?;
assert_eq!(not_precise.nanoseconds(), 100_000_000);

let precise = SecfracDigitsStr::from_str("012345678")?;
assert_eq!(precise.nanoseconds(), 012_345_678);

let more_precise = SecfracDigitsStr::from_str("876543210999")?;
assert_eq!(more_precise.nanoseconds(), 876_543_210);

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

Returns a nanoseconds precision substring if there are enough digits.

Examples

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

let precise = SecfracDigitsStr::from_str("012345678")?;
assert_eq!(precise.nanoseconds_digits().unwrap(), "012345678");

let more_precise = SecfracDigitsStr::from_str("012345678901")?;
assert_eq!(more_precise.nanoseconds_digits().unwrap(), "012345678");

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

Returns a nanoseconds precision substring if there are enough digits.

Examples

let mut buf = "012345678901".to_owned();
let digits = SecfracDigitsStr::from_mut_str(&mut buf)?;
assert_eq!(digits.as_str(), "012345678901");

digits.nanoseconds_digits_mut().unwrap().fill_with_zero();
assert_eq!(digits.as_str(), "000000000901");

`#[must_use]pub fn nanoseconds_bytes_fixed_len(&self) -> Option<&[u8; 9]>`[src]

Returns a nanoseconds digits as a fixed bytes slice, if there are enough digits.

Examples

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

let precise = SecfracDigitsStr::from_str("012345678")?;
assert_eq!(precise.nanoseconds_bytes_fixed_len(), Some(b"012345678"));

let more_precise = SecfracDigitsStr::from_str("012345678901")?;
assert_eq!(more_precise.nanoseconds_bytes_fixed_len(), Some(b"012345678"));

`pub fn fill_with_zero(&mut self)`[src]

Fills the secfrac part with zero.

Examples

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

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

assert_eq!(buf, "0000");

`pub fn fill_with_nine(&mut self)`[src]

Fills the secfrac part with zero.

Examples

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

secfrac.fill_with_nine();
assert_eq!(secfrac.as_str(), "9999");

assert_eq!(buf, "9999");