Struct `WriterPanicked`

pub struct WriterPanicked { pub(in ::io::buffered::bufwriter) buf: Vec<u8> }

Error returned for the buffered data from BufWriter::into_parts, when the underlying writer has previously panicked. Contains the (possibly partly written) buffered data.

Example

# // This test requires unwinding to work.
# // Disable it when unwinding isn't available.
# #[cfg(panic = "unwind")]
# fn main() {
use std::io::{self, BufWriter, Write};
use std::panic::{catch_unwind, AssertUnwindSafe};

struct PanickingWriter;
impl Write for PanickingWriter {
  fn write(&mut self, buf: &[u8]) -> io::Result<usize> { panic!() }
  fn flush(&mut self) -> io::Result<()> { panic!() }
}

let mut stream = BufWriter::new(PanickingWriter);
write!(stream, "some data").unwrap();
let result = catch_unwind(AssertUnwindSafe(|| {
    stream.flush().unwrap()
}));
assert!(result.is_err());
let (recovered_writer, buffered_data) = stream.into_parts();
assert!(matches!(recovered_writer, PanickingWriter));
assert_eq!(buffered_data.unwrap_err().into_inner(), b"some data");
# }
# #[cfg(not(panic = "unwind"))]
# fn main() {}

Fields

buf: Vec<u8>

Implementations

`impl WriterPanicked`

fn into_inner(self) -> Vec<u8>: Returns the perhaps-unwritten data. Some of this data may have been written by the panicking call(s) to the underlying writer, so simply writing it again is not a good idea.

Trait Implementations

`impl Debug for WriterPanicked`

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

`impl Display for WriterPanicked`

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

`impl Error for WriterPanicked`

Auto Trait Implementations

`impl Freeze for WriterPanicked`

`impl RefUnwindSafe for WriterPanicked`

`impl Send for WriterPanicked`

`impl Sync for WriterPanicked`

`impl Unpin for WriterPanicked`

`impl UnsafeUnpin for WriterPanicked`

`impl UnwindSafe for WriterPanicked`

Blanket Implementations

`impl<T> Any for WriterPanicked where T: 'static + ?Sized,`

fn type_id(&self) -> TypeId

`impl<T> Borrow<T> for WriterPanicked where T: ?Sized,`

fn borrow(&self) -> &T

`impl<T> BorrowMut<T> for WriterPanicked where T: ?Sized,`

fn borrow_mut(&mut self) -> &mut T

`impl<T> From<T> for WriterPanicked`

fn from(t: T) -> T: Returns the argument unchanged.

`impl<T> SizeHint for WriterPanicked where T: ?Sized,`

fn lower_bound(&self) -> usize
fn upper_bound(&self) -> Option<usize>

`impl<T> SizedTypeProperties for WriterPanicked`

`impl<T> ToString for WriterPanicked where T: Display + ?Sized,`

fn to_string(&self) -> String

`impl<T, U> Into<U> for WriterPanicked where U: From<T>,`

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of [From]<T> for U chooses to do.

`impl<T, U> TryFrom<U> for WriterPanicked where U: Into<T>,`

type Error = Infallible;
fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

`impl<T, U> TryInto<U> for WriterPanicked where U: TryFrom<T>,`

type Error = <U as TryFrom<T>>::Error;
fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>