Enum dicom_parser::dataset::LazyDataToken

#[non_exhaustive]
pub enum LazyDataToken<D> {
    ElementHeader(DataElementHeader),
    SequenceStart {
        tag: Tag,
        len: Length,
    },
    PixelSequenceStart,
    SequenceEnd,
    ItemStart {
        len: Length,
    },
    ItemEnd,
    LazyValue {
        header: DataElementHeader,
        decoder: D,
    },
    LazyItemValue {
        len: u32,
        decoder: D,
    },
}

A lazy data token for reading a data set without requiring values to be fully read in memory. This is part of the interpretation of a data set as a stream of symbols, which may either represent data headers or actual value data.

The parameter type D represents the original type of the stateful decoder, and through which the values can be retrieved.

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

ElementHeader(DataElementHeader)

A data header of a primitive value.

SequenceStart

Fields

tag: Tag

len: Length

The beginning of a sequence element.

PixelSequenceStart

The beginning of an encapsulated pixel data element.

SequenceEnd

The ending delimiter of a sequence or encapsulated pixel data.

ItemStart

Fields

len: Length

The beginning of a new item in the sequence.

ItemEnd

The ending delimiter of an item.

LazyValue

Fields

header: DataElementHeader

the header of the respective value

decoder: D

the stateful decoder for fetching the bytes of the value

An element value yet to be fetched

LazyItemValue

Fields

len: u32

the full length of the value, always well defined

decoder: D

the stateful decoder for fetching the bytes of the value

An item value yet to be fetched

Implementations

impl<D> LazyDataToken<D>

pub fn is_sequence_start(&self) -> bool

Check whether this token represents the start of a sequence of nested data sets.

pub fn is_sequence_end(&self) -> bool

Check whether this token represents the end of a sequence or the end of an encapsulated element.

impl<D> LazyDataToken<D>where D: StatefulDecode,

pub fn skip(self) -> Result<()>

pub fn into_owned(self) -> Result<DataToken>

Construct the data token into memory, consuming the reader if necessary.

If the token represents a lazy element value, the inner decoder is read with string preservation.

pub fn into_owned_with_strategy( self, strategy: ValueReadStrategy ) -> Result<DataToken>

Construct the data token into memory, consuming the reader if necessary.

If the token represents a lazy element value, the inner decoder is read with the given value reading strategy.

pub fn into_value_with_strategy( self, strategy: ValueReadStrategy ) -> Result<PrimitiveValue>

Retrieve a primitive element value from the token, consuming the reader with the given reading strategy.

The operation fails if the token does not represent an element value.

pub fn into_value(self) -> Result<PrimitiveValue>

Retrieve a primitive element value from the token, consuming the reader with the default reading strategy.

The operation fails if the token does not represent an element value.

pub fn read_value_into<W>(self, out: W) -> Result<()>where W: Write,

Read the bytes of a value into the given writer, consuming the reader.

This operation will not interpret the value, like in the Bytes value reading strategy. It works for both data elements and non-dataset items.

The operation fails if the token does not represent an element or item value.

pub fn into_repr(self) -> LazyDataTokenRepr

Convert this token into a structured representation, for diagnostics and error reporting purposes.

pub fn repr(&self) -> LazyDataTokenRepr

Create a structured representation of this token, for diagnostics and error reporting purposes.

Trait Implementations

impl<D: Debug> Debug for LazyDataToken<D>

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

Formats the value using the given formatter.

impl<D> From<&LazyDataToken<D>> for LazyDataTokenRepr

fn from(token: &LazyDataToken<D>) -> Self

Converts to this type from the input type.

impl<D> From<LazyDataToken<D>> for LazyDataTokenRepr

fn from(token: LazyDataToken<D>) -> Self

Converts to this type from the input type.