Struct DicomTime 

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

Represents a Dicom time (TM) value with a partial precision, where some time components may be missing.

Unlike chrono::NaiveTime, this implementation has only 6 digit precision for fraction of a second.

DicomTime implements AsRange trait, enabling to retrieve specific time values.

Example

use chrono::NaiveTime;
use dicom_core::value::{DicomTime, AsRange};

let time = DicomTime::from_hm(12, 30)?;

assert_eq!(
    Some(time.latest()?),
    NaiveTime::from_hms_micro_opt(12, 30, 59, 999_999)
);

let milli = DicomTime::from_hms_milli(12, 30, 59, 123)?;

// value still not precise to microsecond
assert_eq!(milli.is_precise(), false);

assert_eq!(milli.to_string(), "12:30:59.123");

// for convenience, is precise enough to be retrieved as a NaiveTime
assert_eq!(
    Some(milli.to_naive_time()?),
    NaiveTime::from_hms_micro_opt(12, 30, 59, 123_000)
);

let time = DicomTime::try_from(&NaiveTime::from_hms_opt(12, 30, 59).unwrap())?;
// conversion from chrono value leads to a precise value
assert_eq!(time.is_precise(), true);

Implementations

impl DicomTime

pub fn from_h(hour: u8) -> Result<DicomTime, Error>

Constructs a new DicomTime with hour precision (HH).

pub fn from_hm(hour: u8, minute: u8) -> Result<DicomTime, Error>

Constructs a new DicomTime with hour and minute precision (HHMM).

pub fn from_hms(hour: u8, minute: u8, second: u8) -> Result<DicomTime, Error>

Constructs a new DicomTime with hour, minute and second precision (HHMMSS).

pub fn from_hms_milli( hour: u8, minute: u8, second: u8, millisecond: u32, ) -> Result<DicomTime, Error>

Constructs a new DicomTime from an hour, minute, second and millisecond value, which leads to the precision HHMMSS.FFF. Millisecond cannot exceed 999.

pub fn from_hms_micro( hour: u8, minute: u8, second: u8, microsecond: u32, ) -> Result<DicomTime, Error>

Constructs a new DicomTime from an hour, minute, second and microsecond value, which leads to the full precision HHMMSS.FFFFFF.

Microsecond cannot exceed 999_999. Instead, leap seconds can be represented by setting second to 60.

pub fn hour(&self) -> &u8

Retrieves the hour from a time as a reference

pub fn minute(&self) -> Option<&u8>

Retrieves the minute from a time as a reference

pub fn second(&self) -> Option<&u8>

Retrieves the minute from a time as a reference

pub fn millisecond(&self) -> Option<u32>

Retrieves the fraction of a second in milliseconds.

Only returns Some(_) if the time is precise to the millisecond or more. Any precision beyond the millisecond is discarded.

pub fn fraction_micro(&self) -> Option<u32>

Retrieves the total known fraction of a second in microseconds.

Only returns None if the time value defines no fraction of a second.

Example

let time: DicomTime = "202346.2500".parse()?;
assert_eq!(time.fraction_micro(), Some(250_000));

let time: DicomTime = "202346".parse()?;
assert_eq!(time.fraction_micro(), None);

pub fn fraction_ms(&self) -> Option<u32>

Retrieves the total known fraction of a second in milliseconds.

This may result in precision loss if the time value was more precise than 3 decimal places.

Only returns None if the time value defines no fraction of a second.

Example

let time: DicomTime = "202346.2500".parse()?;
assert_eq!(time.fraction_ms(), Some(250));

let time: DicomTime = "202346".parse()?;
assert_eq!(time.fraction_ms(), None);

pub fn fraction_precision(&self) -> u8

Retrieves the precision of the fraction of a second, in number of decimal places (in 0..=6).

pub fn fraction_str(&self) -> String

Retrieves the fraction of a second encoded as a small string. The length of the string matches the number of known decimal places in the fraction of a second. Returns an empty string if the time value defines no fraction of a second.

Example

let time: DicomTime = "202346.2500".parse()?;
assert_eq!(&time.fraction_str(), "2500");

let time: DicomTime = "202346".parse()?;
assert_eq!(&time.fraction_str(), "");

impl DicomTime

pub fn to_encoded(&self) -> String

Retrieves a dicom encoded string representation of the value.

impl DicomTime

pub fn to_naive_time(self) -> Result<NaiveTime, Error>

Retrieves a chrono::NaiveTime if the value is precise up to the second.

Missing second fraction defaults to zero.

Trait Implementations

impl AsRange for DicomTime

type PreciseValue = NaiveTime

type Range = TimeRange

fn is_precise(&self) -> bool

returns true if value has all possible date / time components

fn earliest(&self) -> Result<Self::PreciseValue, Error>

Returns the earliest possible value from a partial precision structure. Missing components default to 1 (days, months) or 0 (hours, minutes, …) If structure contains invalid combination of DateComponents, it fails.

fn latest(&self) -> Result<Self::PreciseValue, Error>

Returns the latest possible value from a partial precision structure. If structure contains invalid combination of DateComponents, it fails.

fn range(&self) -> Result<Self::Range, Error>

Returns a tuple of the earliest and latest possible value from a partial precision structure.

fn exact(&self) -> Result<Self::PreciseValue, Error>

Returns a corresponding precise value, if the partial precision structure has full accuracy.

impl Clone for DicomTime

fn clone(&self) -> DicomTime

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for DicomTime

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

Formats the value using the given formatter.

impl Display for DicomTime

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

Formats the value using the given formatter.

impl From<DicomTime> for PrimitiveValue

fn from(value: DicomTime) -> Self

Converts to this type from the input type.

impl<I, P> From<DicomTime> for Value<I, P>

fn from(value: DicomTime) -> Self

Converts the DICOM time into a primitive value.

impl FromStr for DicomTime

type Err = Error

The associated error which can be returned from parsing.

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

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

impl PartialEq for DicomTime

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl TryFrom<&NaiveTime> for DicomTime

type Error = Error

The type returned in the event of a conversion error.

fn try_from(time: &NaiveTime) -> Result<Self, Error>

Performs the conversion.

impl Copy for DicomTime

impl StructuralPartialEq for DicomTime