Let me just throw some thoughts here.
I think this PR is a quick fix but doesn't achieve the likes of encoding standard comparable to say DCMTK.

To implement the recalculation strategy, I think there are 2 ways to approach this:
1.DataSetWriter will peek() at the following tokens. Encoder will write to a byte sink, throwing the output away but counting the bytes written. Then set the Sequence length to bytes written. Continue writing / encoding as before ...

2. Instead of a byte sink, encoder will write to memory. After setting the calculated Sequence length. Writer will write_all() of the memory buffer. This is more efficient.

encoder is strongly coupled with write target using the StatefulEncoder.

This makes it impossible for the DataSetWriter to include a second (and possible third) printer / encoder with a different write target (own Vec, sink). It's because the StatefulEncoder::new() moves in and encoder value which, at this point would have to be Clone d and used to encode to a different target. The EncoderTo trait object cannot be Clone.

If you would be willing to approve the recalculation strategy, how would you go about changing the current abstractions ?

Could we just make the StatefulEncoder have a flag to change the internal self.encoder write target, e.g. switch between
self.to , std::io::Sink and Vec<u8> ?

Thank you

You are right, there is a rather tight connection between the encoder and the write destination at the moment. This is also the case for decoders, with its own set of problems alongside it. Performance-wise this has been mitigated through a BufWriter, but if I understood correctly, the problem is that we cannot write an accurate length field before we actually go through the whole content associated with that length. For primitive values the solution is trivial, but it stops being so when working with sequence data.

I wouldn't mind relaxing this constraint (as in changing the encoder-writer type handshake), but I suspect this would come with substantial rewriting all the way down from the dicom-encoding crate. But maybe there are simpler alternatives.

• StatefulEncoder already has a buffer, so we may be able to extend it to support accumulating even more data before it flushes to the encoder.
• Or, with something like the code below, we can create a new stateful encoder which writes the data somewhere else, allowing the data set writer to devise more sequence writing strategies.

impl<W, E, T> StatefulEncoder<W, E, T> {
    pub fn for_writer<U>(&self, to: U) -> StatefulEncoder<U, E, T>
    where
        U: Write,
        E: Clone,
        T: Clone,
    {
        StatefulEncoder {
            to,
            encoder: self.encoder.clone(),
            text: self.text.clone(),
            bytes_written: self.bytes_written,
            buffer: self.buffer.clone(),
        }
    }
}

Let me know if you will want to reiterate on this PR of you'd like it to be admitted as is.