Struct dicom_parser::stateful::encode::StatefulEncoder

pub struct StatefulEncoder<W, E, T = SpecificCharacterSet> { /* private fields */ }

Also called a printer, this encoder type provides a stateful mid-level abstraction for writing DICOM content. Unlike Encode, the stateful encoder knows how to write text values and keeps track of how many bytes were written. W is the write target, E is the encoder, and T is the text codec.

Implementations

impl<W, E, T> StatefulEncoder<W, E, T>

pub fn new(to: W, encoder: E, text: T) -> Self

impl<'s> StatefulEncoder<Box<dyn Write + 'w, Global>, Box<dyn EncodeTo<dyn Write + 'static> + 'w, Global>, SpecificCharacterSet>

pub fn from_transfer_syntax(
    to: Box<dyn Write + 's>,
    ts: TransferSyntax,
    charset: SpecificCharacterSet
) -> Result<Self>

impl<W, E> StatefulEncoder<W, E> where
    W: Write,
    E: EncodeTo<W>, 

pub fn encode_element_header(&mut self, de: DataElementHeader) -> Result<()>

Encode and write a data element header.

pub fn encode_item_header(&mut self, len: u32) -> Result<()>

Encode and write an item header, where len is the specified length of the item (can be 0xFFFF_FFFF for undefined length).

pub fn encode_item_delimiter(&mut self) -> Result<()>

Encode and write an item delimiter.

pub fn encode_sequence_delimiter(&mut self) -> Result<()>

Encode and write a sequence delimiter.

pub fn write_raw_bytes(&mut self, bytes: &[u8]) -> Result<()>

Write the given bytes directly to the inner writer.

Note that this method (unlike write_bytes) does not perform any additional padding.

pub fn write_bytes(&mut self, bytes: &[u8]) -> Result<()>

Write a primitive DICOM value as a bunch of bytes directly to the inner writer.

This method will perform the necessary padding (always with zeros) to ensure that the encoded value has an even number of bytes.

pub fn bytes_written(&self) -> u64

Retrieve the number of bytes written so far by this printer.

pub fn encode_offset_table(&mut self, table: &[u32]) -> Result<()>

Encode and write the values of a pixel data offset table.

pub fn encode_primitive_element(
    &mut self,
    de: &DataElementHeader,
    value: &PrimitiveValue
) -> Result<()>

Encode and write a data element with a primitive value.

This method will perform the necessary padding to ensure that the encoded value is an even number of bytes. Where applicable, this will use the inner text codec for textual values. The length property of the header is ignored, the true byte length of the value in its encoded form is used instead.

pub fn encode_primitive(
    &mut self,
    de: &DataElementHeader,
    value: &PrimitiveValue
) -> Result<()>

👎 Deprecated since 0.5.0:

use encode_primitive_element instead

Encode and write a primitive value.

Its use is not recommended because the encoded value’s real length might not match the header’s length, leading to an inconsistent data set.

Trait Implementations

impl<W: Debug, E: Debug, T: Debug> Debug for StatefulEncoder<W, E, T>

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

Formats the value using the given formatter.