Struct otter_api_tests::imports::base64::write::EncoderWriter [−]
pub struct EncoderWriter<W> where
W: Write, { /* fields omitted */ }
Expand description
A Write
implementation that base64 encodes data before delegating to the wrapped writer.
Because base64 has special handling for the end of the input data (padding, etc), there’s a
finish()
method on this type that encodes any leftover input bytes and adds padding if
appropriate. It’s called automatically when deallocated (see the Drop
implementation), but
any error that occurs when invoking the underlying writer will be suppressed. If you want to
handle such errors, call finish()
yourself.
Examples
use std::io::Write; // use a vec as the simplest possible `Write` -- in real code this is probably a file, etc. let mut enc = base64::write::EncoderWriter::new(Vec::new(), base64::STANDARD); // handle errors as you normally would enc.write_all(b"asdf").unwrap(); // could leave this out to be called by Drop, if you don't care // about handling errors or getting the delegate writer back let delegate = enc.finish().unwrap(); // base64 was written to the writer assert_eq!(b"YXNkZg==", &delegate[..]);
Panics
Calling write()
(or related methods) or finish()
after finish()
has completed without
error is invalid and will panic.
Errors
Base64 encoding itself does not generate errors, but errors from the wrapped writer will be
returned as per the contract of Write
.
Performance
It has some minor performance loss compared to encoding slices (a couple percent). It does not do any heap allocation.
Implementations
impl<W> EncoderWriter<W> where
W: Write,
impl<W> EncoderWriter<W> where
W: Write,
pub fn new(w: W, config: Config) -> EncoderWriter<W>ⓘNotable traits for EncoderWriter<W>
impl<W> Write for EncoderWriter<W> where
W: Write,
pub fn new(w: W, config: Config) -> EncoderWriter<W>ⓘNotable traits for EncoderWriter<W>
impl<W> Write for EncoderWriter<W> where
W: Write,
Create a new encoder that will write to the provided delegate writer w
.
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.
Trait Implementations
impl<W> Debug for EncoderWriter<W> where
W: Write,
impl<W> Debug for EncoderWriter<W> where
W: Write,
impl<W> Drop for EncoderWriter<W> where
W: Write,
impl<W> Drop for EncoderWriter<W> where
W: Write,
impl<W> Write for EncoderWriter<W> where
W: Write,
impl<W> Write for EncoderWriter<W> where
W: Write,
Encode input and then write to the delegate writer.
Under non-error circumstances, this returns Ok
with the value being the number of bytes
of input
consumed. The value may be 0
, which interacts poorly with write_all
, which
interprets Ok(0)
as an error, despite it being allowed by the contract of write
. See
https://github.com/rust-lang/rust/issues/56889 for more on that.
If the previous call to write
provided more (encoded) data than the delegate writer could
accept in a single call to its write
, the remaining data is buffered. As long as buffered
data is present, subsequent calls to write
will try to write the remaining buffered data
to the delegate and return either Ok(0)
– and therefore not consume any of input
– or
an error.
Errors
Any errors emitted by the delegate writer are returned.
Because this is usually treated as OK to call multiple times, it will not flush any incomplete chunks of input or write padding.
Errors
The first error that is not of ErrorKind::Interrupted
will be returned.
can_vector
)Determines if this Write
r has an efficient write_vectored
implementation. Read more
Attempts to write an entire buffer into this writer. Read more
write_all_vectored
)Attempts to write multiple buffers into this writer. Read more
Writes a formatted string into this writer, returning any error encountered. Read more
Auto Trait Implementations
impl<W> RefUnwindSafe for EncoderWriter<W> where
W: RefUnwindSafe,
impl<W> Send for EncoderWriter<W> where
W: Send,
impl<W> Sync for EncoderWriter<W> where
W: Sync,
impl<W> Unpin for EncoderWriter<W> where
W: Unpin,
impl<W> UnwindSafe for EncoderWriter<W> where
W: UnwindSafe,
Blanket Implementations
Mutably borrows from an owned value. Read more
pub fn into_any(self: Box<T, Global>) -> Box<dyn Any + 'static, Global>ⓘNotable traits for Box<R, Global>
impl<R> Read for Box<R, Global> where
R: Read + ?Sized, impl<W> Write for Box<W, Global> where
W: Write + ?Sized, impl<I, A> Iterator for Box<I, A> where
A: Allocator,
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<F, A> Future for Box<F, A> where
A: Allocator + 'static,
F: Future + Unpin + ?Sized, type Output = <F as Future>::Output;
pub fn into_any(self: Box<T, Global>) -> Box<dyn Any + 'static, Global>ⓘNotable traits for Box<R, Global>
impl<R> Read for Box<R, Global> where
R: Read + ?Sized, impl<W> Write for Box<W, Global> where
W: Write + ?Sized, impl<I, A> Iterator for Box<I, A> where
A: Allocator,
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<F, A> Future for Box<F, A> where
A: Allocator + 'static,
F: Future + Unpin + ?Sized, type Output = <F as Future>::Output;
Convert Box<dyn Trait>
(where Trait: Downcast
) to Box<dyn Any>
. Box<dyn Any>
can
then be further downcast
into Box<ConcreteType>
where ConcreteType
implements Trait
. Read more
pub fn into_any_rc(self: Rc<T>) -> Rc<dyn Any + 'static>
pub fn into_any_rc(self: Rc<T>) -> Rc<dyn Any + 'static>
Convert Rc<Trait>
(where Trait: Downcast
) to Rc<Any>
. Rc<Any>
can then be
further downcast
into Rc<ConcreteType>
where ConcreteType
implements Trait
. Read more
Convert &Trait
(where Trait: Downcast
) to &Any
. This is needed since Rust cannot
generate &Any
’s vtable from &Trait
’s. Read more
pub fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)
pub fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)
Convert &mut Trait
(where Trait: Downcast
) to &Any
. This is needed since Rust cannot
generate &mut Any
’s vtable from &mut Trait
’s. Read more
impl<A> DynCastExt for A
impl<A> DynCastExt for A
pub fn dyn_cast<T>(
self
) -> Result<<A as DynCastExtHelper<T>>::Target, <A as DynCastExtHelper<T>>::Source> where
T: ?Sized,
A: DynCastExtHelper<T>,
pub fn dyn_cast<T>(
self
) -> Result<<A as DynCastExtHelper<T>>::Target, <A as DynCastExtHelper<T>>::Source> where
T: ?Sized,
A: DynCastExtHelper<T>,
Use this to cast from one trait object type to another. Read more
pub fn dyn_upcast<T>(self) -> <A as DynCastExtAdvHelper<T, T>>::Target where
T: ?Sized,
A: DynCastExtAdvHelper<T, T, Source = <A as DynCastExtAdvHelper<T, T>>::Target>,
pub fn dyn_upcast<T>(self) -> <A as DynCastExtAdvHelper<T, T>>::Target where
T: ?Sized,
A: DynCastExtAdvHelper<T, T, Source = <A as DynCastExtAdvHelper<T, T>>::Target>,
Use this to upcast a trait to one of its supertraits. Read more
pub fn dyn_cast_adv<F, T>(
self
) -> Result<<A as DynCastExtAdvHelper<F, T>>::Target, <A as DynCastExtAdvHelper<F, T>>::Source> where
T: ?Sized,
A: DynCastExtAdvHelper<F, T>,
F: ?Sized,
pub fn dyn_cast_adv<F, T>(
self
) -> Result<<A as DynCastExtAdvHelper<F, T>>::Target, <A as DynCastExtAdvHelper<F, T>>::Source> where
T: ?Sized,
A: DynCastExtAdvHelper<F, T>,
F: ?Sized,
pub fn dyn_cast_with_config<C>(
self
) -> Result<<A as DynCastExtAdvHelper<<C as DynCastConfig>::Source, <C as DynCastConfig>::Target>>::Target, <A as DynCastExtAdvHelper<<C as DynCastConfig>::Source, <C as DynCastConfig>::Target>>::Source> where
C: DynCastConfig,
A: DynCastExtAdvHelper<<C as DynCastConfig>::Source, <C as DynCastConfig>::Target>,
pub fn dyn_cast_with_config<C>(
self
) -> Result<<A as DynCastExtAdvHelper<<C as DynCastConfig>::Source, <C as DynCastConfig>::Target>>::Target, <A as DynCastExtAdvHelper<<C as DynCastConfig>::Source, <C as DynCastConfig>::Target>>::Source> where
C: DynCastConfig,
A: DynCastExtAdvHelper<<C as DynCastConfig>::Source, <C as DynCastConfig>::Target>,
Use this to cast from one trait object type to another. With this method the type parameter is a config type that uniquely specifies which cast should be preformed. Read more
fn instrument(self, span: Span) -> Instrumented<Self>ⓘNotable traits for Instrumented<T>
impl<T> Future for Instrumented<T> where
T: Future, type Output = <T as Future>::Output;
[src]
fn instrument(self, span: Span) -> Instrumented<Self>ⓘNotable traits for Instrumented<T>
impl<T> Future for Instrumented<T> where
T: Future, type Output = <T as Future>::Output;
[src]Instruments this type with the provided Span
, returning an
Instrumented
wrapper. Read more
fn in_current_span(self) -> Instrumented<Self>ⓘNotable traits for Instrumented<T>
impl<T> Future for Instrumented<T> where
T: Future, type Output = <T as Future>::Output;
[src]
fn in_current_span(self) -> Instrumented<Self>ⓘNotable traits for Instrumented<T>
impl<T> Future for Instrumented<T> where
T: Future, type Output = <T as Future>::Output;
[src]pub fn vzip(self) -> V
impl<W> WriteBytesExt for W where
W: Write + ?Sized,
impl<W> WriteBytesExt for W where
W: Write + ?Sized,
Writes an unsigned 8 bit integer to the underlying writer. Read more
Writes a signed 8 bit integer to the underlying writer. Read more
Writes an unsigned 16 bit integer to the underlying writer. Read more
Writes a signed 16 bit integer to the underlying writer. Read more
Writes an unsigned 24 bit integer to the underlying writer. Read more
Writes a signed 24 bit integer to the underlying writer. Read more
Writes an unsigned 32 bit integer to the underlying writer. Read more
Writes a signed 32 bit integer to the underlying writer. Read more
Writes an unsigned 48 bit integer to the underlying writer. Read more
Writes a signed 48 bit integer to the underlying writer. Read more
Writes an unsigned 64 bit integer to the underlying writer. Read more
Writes a signed 64 bit integer to the underlying writer. Read more
fn write_u128<T>(&mut self, n: u128) -> Result<(), Error> where
T: ByteOrder,
fn write_u128<T>(&mut self, n: u128) -> Result<(), Error> where
T: ByteOrder,
Writes an unsigned 128 bit integer to the underlying writer.
fn write_i128<T>(&mut self, n: i128) -> Result<(), Error> where
T: ByteOrder,
fn write_i128<T>(&mut self, n: i128) -> Result<(), Error> where
T: ByteOrder,
Writes a signed 128 bit integer to the underlying writer.
Writes an unsigned n-bytes integer to the underlying writer. Read more
Writes a signed n-bytes integer to the underlying writer. Read more
Writes an unsigned n-bytes integer to the underlying writer. Read more
Writes a signed n-bytes integer to the underlying writer. Read more
Writes a IEEE754 single-precision (4 bytes) floating point number to the underlying writer. Read more