[encoding] Refactor EncodeTo

- do not impl EncodeTo for all Encode,
 - instead use wrapper type EncoderFor

Author: Enet4

encoding/src/encode/mod.rs

@@ -363,33 +363,99 @@ pub trait EncodeTo<W: ?Sized> {
         W: Write;
 }
 
-impl<T, W: ?Sized> EncodeTo<W> for T
+impl<T, W: ?Sized> EncodeTo<W> for &T
 where
-    T: Encode,
-    W: Write,
+    T: EncodeTo<W>,
 {
-    fn encode_tag(&self, to: &mut W, tag: Tag) -> Result<()> {
-        Encode::encode_tag(self, to, tag)
+    fn encode_tag(&self, to: &mut W, tag: Tag) -> Result<()>
+    where
+        W: Write
+    {
+        (**self).encode_tag(to, tag)
     }
 
-    fn encode_element_header(&self, to: &mut W, de: DataElementHeader) -> Result<usize> {
-        Encode::encode_element_header(self, to, de)
+    fn encode_element_header(&self, to: &mut W, de: DataElementHeader) -> Result<usize>
+    where
+        W: Write
+    {
+        (**self).encode_element_header(to, de)
     }
 
-    fn encode_item_header(&self, to: &mut W, len: u32) -> Result<()> {
-        Encode::encode_item_header(self, to, len)
+    fn encode_item_header(&self, to: &mut W, len: u32) -> Result<()>
+    where
+        W: Write
+    {
+        (**self).encode_item_header(to, len)
     }
 
-    fn encode_item_delimiter(&self, to: &mut W) -> Result<()> {
-        Encode::encode_item_delimiter(self, to)
+    fn encode_item_delimiter(&self, to: &mut W) -> Result<()>
+    where
+        W: Write
+    {
+        (**self).encode_item_delimiter(to)
     }
 
-    fn encode_sequence_delimiter(&self, to: &mut W) -> Result<()> {
-        Encode::encode_sequence_delimiter(self, to)
+    fn encode_sequence_delimiter(&self, to: &mut W) -> Result<()>
+    where
+        W: Write
+    {
+        (**self).encode_sequence_delimiter(to)
     }
 
-    fn encode_primitive(&self, to: &mut W, value: &PrimitiveValue) -> Result<usize> {
-        Encode::encode_primitive(self, to, value)
+    /// Encode and write a primitive DICOM value to the given destination.
+    fn encode_primitive(&self, to: &mut W, value: &PrimitiveValue) -> Result<usize>
+    where
+        W: Write
+    {
+        (**self).encode_primitive(to, value)
+    }
+}
+
+impl<T: ?Sized, W: ?Sized> EncodeTo<W> for Box<T>
+where
+    T: EncodeTo<W>,
+{
+    fn encode_tag(&self, to: &mut W, tag: Tag) -> Result<()>
+    where
+        W: Write
+    {
+        (**self).encode_tag(to, tag)
+    }
+
+    fn encode_element_header(&self, to: &mut W, de: DataElementHeader) -> Result<usize>
+    where
+        W: Write
+    {
+        (**self).encode_element_header(to, de)
+    }
+
+    fn encode_item_header(&self, to: &mut W, len: u32) -> Result<()>
+    where
+        W: Write
+    {
+        (**self).encode_item_header(to, len)
+    }
+
+    fn encode_item_delimiter(&self, to: &mut W) -> Result<()>
+    where
+        W: Write
+    {
+        (**self).encode_item_delimiter(to)
+    }
+
+    fn encode_sequence_delimiter(&self, to: &mut W) -> Result<()>
+    where
+        W: Write
+    {
+        (**self).encode_sequence_delimiter(to)
+    }
+
+    /// Encode and write a primitive DICOM value to the given destination.
+    fn encode_primitive(&self, to: &mut W, value: &PrimitiveValue) -> Result<usize>
+    where
+        W: Write
+    {
+        (**self).encode_primitive(to, value)
     }
 }
 
@@ -536,11 +602,12 @@ mod tests {
     fn boxed_encode_is_encode<T>(encoder: T)
     where
         T: Encode,
+        T: Copy,
     {
         is_encode(&encoder);
-        is_encode_to::<dyn Write, _>(&encoder);
+        is_encode_to::<dyn Write, _>(&EncoderFor::new(encoder));
         let boxed = Box::new(encoder);
         is_encode(&boxed);
-        is_encode_to::<dyn Write, _>(&boxed);
+        is_encode_to::<dyn Write, _>(&EncoderFor::new(boxed));
     }
 }

encoding/src/transfer_syntax/mod.rs

@@ -15,7 +15,7 @@ pub mod implicit_le;
 
 use crate::decode::basic::BasicDecoder;
 use crate::decode::DecodeFrom;
-use crate::encode::EncodeTo;
+use crate::encode::{EncodeTo, EncoderFor};
 use std::io::{Read, Write};
 
 pub use byteordered::Endianness;
@@ -24,7 +24,7 @@ pub use byteordered::Endianness;
 pub type DynDecoder<S> = Box<dyn DecodeFrom<S>>;
 
 /// An encoder with its type erased.
-pub type DynEncoder<W> = Box<dyn EncodeTo<W>>;
+pub type DynEncoder<'w, W> = Box<dyn EncodeTo<W> + 'w>;
 
 /// A DICOM transfer syntax specifier. The data RW adapter `A` specifies
 /// custom codec capabilities when required.
@@ -309,29 +309,32 @@ impl<A> TransferSyntax<A> {
     /// 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<'w>(&self) -> Option<DynEncoder<dyn Write + 'w>> {
+    pub fn encoder<'w>(&self) -> Option<DynEncoder<'w, dyn Write + 'w>> {
         self.encoder_for()
     }
 
     /// 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 encoder_for<W>(&self) -> Option<DynEncoder<W>>
+    pub fn encoder_for<'w, W: 'w>(&self) -> Option<DynEncoder<'w, W>>
     where
         Self: Sized,
         W: ?Sized + Write,
     {
         match (self.byte_order, self.explicit_vr) {
             (Endianness::Little, false) => Some(Box::new(
-                implicit_le::ImplicitVRLittleEndianEncoder::default(),
-            )),
+                EncoderFor::new(
+                implicit_le::ImplicitVRLittleEndianEncoder::default())),
+            ),
             (Endianness::Little, true) => Some(Box::new(
-                explicit_le::ExplicitVRLittleEndianEncoder::default(),
-            )),
-            (Endianness::Big, true) => {
-                Some(Box::new(explicit_be::ExplicitVRBigEndianEncoder::default()))
-            }
+                EncoderFor::new(
+                explicit_le::ExplicitVRLittleEndianEncoder::default())),
+            ),
+            (Endianness::Big, true) => Some(Box::new(
+                EncoderFor::new(
+                    explicit_be::ExplicitVRBigEndianEncoder::default())),
+            ),
             _ => None,
         }
     }

parser/src/dataset/write.rs

@@ -3,9 +3,10 @@ use crate::dataset::*;
 use crate::error::{DataSetSyntaxError, Error, Result};
 use crate::stateful::encode::StatefulEncoder;
 use dicom_core::{DataElementHeader, Length, VR};
-use dicom_encoding::encode::{Encode, EncodeTo};
+use dicom_encoding::encode::EncodeTo;
 use dicom_encoding::text::{SpecificCharacterSet, TextCodec};
 use dicom_encoding::TransferSyntax;
+use dicom_encoding::transfer_syntax::DynEncoder;
 use std::io::Write;
 
 /// A writer-specific token representing a sequence or item start.
@@ -28,11 +29,11 @@ pub struct DataSetWriter<W, E, T> {
     last_de: Option<DataElementHeader>,
 }
 
-impl<W> DataSetWriter<W, Box<dyn EncodeTo<W>>, Box<dyn TextCodec>>
+impl<'w, W: 'w> DataSetWriter<W, DynEncoder<'w, W>, Box<dyn TextCodec>>
 where
     W: Write,
 {
-    pub fn with_ts_cs(to: W, ts: TransferSyntax, cs: SpecificCharacterSet) -> Result<Self> {
+    pub fn with_ts_cs(to: W, ts: &TransferSyntax, cs: SpecificCharacterSet) -> Result<Self> {
         let encoder = ts
             .encoder_for()
             .ok_or_else(|| Error::UnsupportedTransferSyntax)?;
@@ -54,10 +55,11 @@ impl<W, E, T> DataSetWriter<W, E, T> {
 impl<W, E, T> DataSetWriter<W, E, T>
 where
     W: Write,
-    E: Encode,
+    E: EncodeTo<W>,
     T: TextCodec,
 {
     /// Feed the given sequence of tokens which are part of the same data set.
+    #[inline]
     pub fn write_sequence<I>(&mut self, tokens: I) -> Result<()>
     where
         I: IntoIterator<Item = DataToken>,
@@ -70,7 +72,6 @@ where
     }
 
     /// Feed the given data set token for writing the data set.
-    #[inline]
     pub fn write(&mut self, token: DataToken) -> Result<()> {
         // adjust the logic of sequence printing:
         // explicit length sequences or items should not print
@@ -161,14 +162,15 @@ mod tests {
         Tag, VR,
     };
     use dicom_encoding::text::DefaultCharacterSetCodec;
+    use dicom_encoding::encode::EncoderFor;
     use dicom_encoding::transfer_syntax::explicit_le::ExplicitVRLittleEndianEncoder;
 
     fn validate_dataset_writer<I>(tokens: I, ground_truth: &[u8])
     where
         I: IntoIterator<Item = DataToken>,
     {
         let mut raw_out: Vec<u8> = vec![];
-        let encoder = ExplicitVRLittleEndianEncoder::default();
+        let encoder = EncoderFor::new(ExplicitVRLittleEndianEncoder::default());
         let text = DefaultCharacterSetCodec::default();
         let mut dset_writer = DataSetWriter::new(&mut raw_out, encoder, text);
 

parser/src/stateful/encode.rs

@@ -9,6 +9,7 @@ use dicom_encoding::{
     text::{DefaultCharacterSetCodec, SpecificCharacterSet, TextCodec},
     TransferSyntax,
 };
+use dicom_encoding::transfer_syntax::DynEncoder;
 use std::io::Write;
 
 /// Also called a printer, this encoder type provides a stateful mid-level
@@ -23,9 +24,9 @@ pub struct StatefulEncoder<W, E, T> {
     bytes_written: u64,
 }
 
-pub type DynStatefulEncoder<'s> =
-    StatefulEncoder<Box<dyn Write + 's>, Box<dyn EncodeTo<dyn Write + 's>>, Box<dyn TextCodec>>;
-
+pub type DynStatefulEncoder<'w> =
+    StatefulEncoder< Box<dyn Write + 'w>, DynEncoder<'w, dyn Write>, Box<dyn TextCodec>>;
+    
 impl<W, E, T> StatefulEncoder<W, E, T> {
     pub fn new(to: W, encoder: E, text: T) -> Self {
         StatefulEncoder {