Struct TransferSyntax

pub struct TransferSyntax<D = Box<dyn DataRWAdapter<Box<dyn Read>, Box<dyn Write>, Reader = Box<dyn Read>, Writer = Box<dyn Write>> + Sync + Send>, R = Box<dyn PixelDataReader + Sync + Send>, W = Box<dyn PixelDataWriter + Sync + Send>> { /* private fields */ }

A DICOM transfer syntax specifier.

Custom encoding and decoding capabilities are defined via the parameter types D and P, The type parameter D specifies an adapter for reading and writing data sets, whereas P specifies the encoder and decoder of encapsulated pixel data.

This type is usually consumed in its “type erased” form, with its default parameter types. On the other hand, implementers of TransferSyntax will typically specify concrete types for D and P, which are type-erased before registration. If the transfer syntax requires no data set codec, D can be assigned to the utility type NeverAdapter. If pixel data encoding/decoding is not needed or not supported, you can assign P to NeverPixelAdapter.

Implementations

impl<D, R, W> TransferSyntax<D, R, W>

pub const fn new( uid: &'static str, name: &'static str, byte_order: Endianness, explicit_vr: bool, codec: Codec<D, R, W>, ) -> TransferSyntax<D, R, W>

Create a new transfer syntax descriptor.

Note that only transfer syntax implementers are expected to construct TS descriptors from scratch. For a practical usage of transfer syntaxes, one should look up an existing transfer syntax registry by UID.

Example

To register a private transfer syntax in your program, use submit_transfer_syntax outside of a function body:

submit_transfer_syntax! {
    TransferSyntax::<NeverAdapter, NeverPixelAdapter, NeverPixelAdapter>::new(
        "1.3.46.670589.33.1.4.1",
        "CT-Private-ELE",
        Endianness::Little,
        true,
        Codec::EncapsulatedPixelData(None, None),
    )
}

pub const fn new_ele( uid: &'static str, name: &'static str, codec: Codec<D, R, W>, ) -> TransferSyntax<D, R, W>

Create a new descriptor for a transfer syntax in explicit VR little endian.

Note that only transfer syntax implementers are expected to construct TS descriptors from scratch. For a practical usage of transfer syntaxes, one should look up an existing transfer syntax registry by UID.

Example

To register a private transfer syntax in your program, use submit_transfer_syntax outside of a function body:

submit_transfer_syntax! {
    TransferSyntax::<NeverAdapter, NeverPixelAdapter, NeverPixelAdapter>::new_ele(
        "1.3.46.670589.33.1.4.1",
        "CT-Private-ELE",
        Codec::EncapsulatedPixelData(None, None),
    )
}

See submit_ele_transfer_syntax for an alternative.

pub const fn uid(&self) -> &'static str

Obtain this transfer syntax’ unique identifier.

pub const fn name(&self) -> &'static str

Obtain the name of this transfer syntax.

pub const fn endianness(&self) -> Endianness

Obtain this transfer syntax’ expected endianness.

pub fn codec(&self) -> &Codec<D, R, W>

Obtain this transfer syntax’ codec specification.

pub fn is_fully_supported(&self) -> bool

Check whether this transfer syntax specifier provides a complete implementation, meaning that it can both decode and encode in this transfer syntax.

pub fn is_codec_free(&self) -> bool

Check whether no codecs are required for this transfer syntax, meaning that a complete implementation is available and no pixel data conversion is required.

pub fn is_unsupported(&self) -> bool

Check whether neither reading nor writing of data sets is supported. If this is true, encoding and decoding will not be available.

pub fn is_unsupported_pixel_encapsulation(&self) -> bool

Check whether reading and writing the pixel data is unsupported. If this is true, encoding and decoding of the data set may still be possible, but the pixel data will only be available in its encapsulated form.

pub fn can_decode_all(&self) -> bool

Check whether this codec can fully decode both data sets and pixel data.

pub fn can_decode_dataset(&self) -> bool

Check whether this codec can decode the data set.

pub fn decoder<'s>(&self) -> Option<Box<dyn DecodeFrom<dyn Read + 's>>>

Retrieve the appropriate data element decoder for this transfer syntax. Can yield none if decoding is not supported.

The resulting decoder does not consider pixel data encapsulation or data set compression rules. This means that the consumer of this method needs to adapt the reader before using the decoder.

pub fn decoder_for<S>(&self) -> Option<Box<dyn DecodeFrom<S>>>

where TransferSyntax<D, R, W>: Sized, S: Read + ?Sized,

Retrieve the appropriate data element decoder for this transfer syntax and given reader type (this method is not object safe). Can yield none if decoding is not supported.

The resulting decoder does not consider pixel data encapsulation or data set compression rules. This means that the consumer of this method needs to adapt the reader before using the decoder.

pub fn encoder<'w>(&self) -> Option<Box<dyn EncodeTo<dyn Write + 'w> + 'w>>

Retrieve the appropriate data element encoder for this transfer syntax. Can yield none if encoding is not supported. The resulting encoder does not consider pixel data encapsulation or data set compression rules.

pub fn encoder_for<'w, T>(&self) -> Option<Box<dyn EncodeTo<T> + 'w>>

where TransferSyntax<D, R, W>: Sized, T: Write + 'w + ?Sized,

Retrieve the appropriate data element encoder for this transfer syntax and the given writer type (this method is not object safe). Can yield none if encoding is not supported. The resulting encoder does not consider pixel data encapsulation or data set compression rules.

pub fn basic_decoder(&self) -> BasicDecoder

Obtain a dynamic basic decoder, based on this transfer syntax’ expected endianness.

pub fn erased(self) -> TransferSyntax

where D: Send + Sync + 'static + DataRWAdapter<Box<dyn Read>, Box<dyn Write>, Reader = Box<dyn Read>, Writer = Box<dyn Write>>, R: Send + Sync + 'static + PixelDataReader, W: Send + Sync + 'static + PixelDataWriter,

Type-erase the pixel data or data set codec.

Trait Implementations

impl<D, R, W> Debug for TransferSyntax<D, R, W>

where D: Debug, R: Debug, W: Debug,

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

Formats the value using the given formatter.