Trait midly::io::Write

pub trait Write {
    type Error;
    type Seekable: Write<Error = Self::Error, Seekable = Self::Seekable> + Seek;

    fn write(&mut self, buf: &[u8]) -> WriteResult<Self>;
    fn invalid_input(msg: &'static str) -> Self::Error;

    fn make_seekable(&mut self) -> Option<&mut Self::Seekable> { ... }
}

A Write trait available even in no_std environments, and with per-type errors.

Required Associated Types

type Error

The error type specific to the writer.

type Seekable: Write<Error = Self::Error, Seekable = Self::Seekable> + Seek

Self when the type is seekable, and NotSeekable<Self> otherwise.

Required Methods

fn write(&mut self, buf: &[u8]) -> WriteResult<Self>

Write a slice of data to the writer.

Should error if not all of the data could be written.

fn invalid_input(msg: &'static str) -> Self::Error

Create an “invalid input”-style error from a string literal.

Provided Methods

fn make_seekable(&mut self) -> Option<&mut Self::Seekable>

Make this writer seekable, if possible.

Implementations on Foreign Types

impl<'a, W: Write> Write for &'a mut W

type Error = <W as Write>::Error

type Seekable = <W as Write>::Seekable

fn write(&mut self, buf: &[u8]) -> WriteResult<W>

fn invalid_input(msg: &'static str) -> W::Error

fn make_seekable(&mut self) -> Option<&mut W::Seekable>

impl Write for Vec<u8>

type Error = &'static str

type Seekable = Vec<u8, Global>

fn write(&mut self, buf: &[u8]) -> WriteResult<Self>

fn invalid_input(msg: &'static str) -> &'static str

fn make_seekable(&mut self) -> Option<&mut Self>

impl<'a> Write for &'a mut [u8]

type Error = CursorError

type Seekable = NotSeekable<&'a mut [u8]>

fn write(&mut self, buf: &[u8]) -> WriteResult<Self>

fn invalid_input(msg: &'static str) -> CursorError

Implementors

impl<'a> Write for Cursor<'a>

type Error = CursorError

type Seekable = Cursor<'a>

impl<T: Write + Seek> Write for SeekableWrap<T>

type Error = Error

type Seekable = SeekableWrap<T>

impl<T: Write> Write for IoWrap<T>

type Error = Error

type Seekable = NotSeekable<IoWrap<T>>

impl<W: Write> Write for NotSeekable<W>

type Error = <W as Write>::Error

type Seekable = NotSeekable<W>