pub fn finish(&mut self) -> Result<W> {
        // If we could consume self in finish(), we wouldn't have to worry about this case, but
        // finish() is retryable in the face of I/O errors, so we can't consume here.
        if self.delegate.is_none() {
            panic!("Encoder has already had finish() called")
        };

        self.write_final_leftovers()?;

        let writer = self.delegate.take().expect("Writer must be present");

        Ok(writer)
    }
/// Encode all remaining buffered data and write it, including any trailing incomplete input
/// triples and associated padding.
///
/// Once this succeeds, no further writes or calls to this method are allowed.
///
/// This may write to the delegate writer multiple times if the delegate writer does not accept
/// all input provided to its `write` each invocation.
///
/// If you don't care about error handling, it is not necessary to call this function, as the
/// equivalent finalization is done by the Drop impl.
///
/// Returns the writer that this was constructed around.
///
/// # Errors
///
/// The first error that is not of `ErrorKind::Interrupted` will be returned.
Encode all remaining buffered data and write it, including any trailing incomplete input
triples and associated padding.

Once this succeeds, no further writes or calls to this method are allowed.

This may write to the delegate writer multiple times if the delegate writer does not accept
all input provided to its `write` each invocation.

If you don't care about error handling, it is not necessary to call this function, as the
equivalent finalization is done by the Drop impl.

Returns the writer that this was constructed around.
Encode all remaining buffered data and write it including any trailing incomplete input triples and associated padding . Once this succeeds no further writes or calls to this method are allowed . This may write to the delegate writer multiple times if the delegate writer does not accept all input provided to its ` write ` each invocation . If you don ' t care about error handling it is not necessary to call this function as the equivalent finalization is done by the Drop impl . Returns the writer that this was constructed around .
pub fn finish(&mut self) -> Result<W> {
        // If we could consume self in finish(), we wouldn't have to worry about this case, but
        // finish() is retryable in the face of I/O errors, so we can't consume here.
        if self.delegate.is_none() {
            panic!("Encoder has already had finish() called")
        };
        self.write_final_leftovers()?;
        let writer = self.delegate.take().expect("Writer must be present");
        Ok(writer)
    }
pub fn finish ( & mut self ) -> Result < W > { // If we could consume self in finish(), we wouldn't have to worry about this case, but // finish() is retryable in the face of I/O errors, so we can't consume here. if self . delegate . is_none ( ) { panic ! ( " " ) } ; self . write_final_leftovers ( ) ? ; let writer = self . delegate . take ( ) . expect ( " " ) ; Ok ( writer ) }
Encode all remaining buffered data and write it, including any trailing incomplete input
triples and associated padding.
Encode all remaining buffered data and write it including any trailing incomplete input triples and associated padding .
&mut self
&mut self
errors
The first error that is not of `ErrorKind::Interrupted` will be returned.
The first error that is not of ` ErrorKind :: Interrupted ` will be returned .