Struct buf::Write

pub struct Write<T, W, A: Alloc> { /* fields omitted */ }

Methods

impl<T, W, A: Alloc> Write<T, W, A>

pub fn with_capacity_in(a: A, w: W, cap: usize) -> Option<Self>

pub const fn from_raw(w: W, raw: RawVec<T, A>) -> Self

pub const fn as_ref(&self) -> &W

pub fn as_mut(&mut self) -> &mut W

impl<T: Copy, W: Write<T>, A: Alloc> Write<T, W, A>

pub fn flush_buffer(     &mut self ) -> Result<(), Either<<W as Write<T>>::Err, EndOfFile>>

Trait Implementations

impl<T: Debug, W: Debug, A: Debug + Alloc> Debug for Write<T, W, A>

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

Formats the value using the given formatter.

impl<T: PartialEq, W: PartialEq, A: PartialEq + Alloc> PartialEq for Write<T, W, A>

fn eq(&self, other: &Write<T, W, A>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Write<T, W, A>) -> bool

This method tests for !=.

impl<T: Eq, W: Eq, A: Eq + Alloc> Eq for Write<T, W, A>

impl<T: PartialOrd, W: PartialOrd, A: PartialOrd + Alloc> PartialOrd for Write<T, W, A>

fn partial_cmp(&self, other: &Write<T, W, A>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Write<T, W, A>) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Write<T, W, A>) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Write<T, W, A>) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Write<T, W, A>) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl<T: Ord, W: Ord, A: Ord + Alloc> Ord for Write<T, W, A>

fn cmp(&self, other: &Write<T, W, A>) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

Compares and returns the minimum of two values.

impl<T: Hash, W: Hash, A: Hash + Alloc> Hash for Write<T, W, A>

fn hash<__HTWA: Hasher>(&self, state: &mut __HTWA)

Feeds this value into the given [Hasher].

fn hash_slice<H>(data: &[Self], state: &mut H) where     H: Hasher,

Feeds a slice of this type into the given [Hasher].

impl<T: Copy, W: Write<T>, A: Alloc> Write<T> for Write<T, W, A>

type Err = Either<W::Err, EndOfFile>

fn flush(&mut self) -> Result<(), Self::Err>

fn write(&mut self, buf: &[T]) -> Result<usize, Self::Err>

w.write(buf) = self.writev(&[buf])

fn writev(&mut self, bufs: &[&[T]]) -> Result<usize, Self::Err>

Push some data, at most bufs.fold(0, |n, buf| n+buf.len()), to this sink from given buffers; return how many data were actually written, or a failure. May block if no data can be written when called.

fn write_all(&mut self, buf: &[T]) -> Result<(), (Self::Err, usize)> where     Self::Err: From<EndOfFile>,

Push buf.len() data to this sink from given buffer; return () if so many data were actually written, or a failure and how many data were written before the failure.

impl<W: Write<u8>, A: Alloc> Write for Write<u8, W, A>

fn write_str(&mut self, s: &str) -> Result

Writes a slice of bytes into this writer, returning whether the write succeeded.

fn write_char(&mut self, c: char) -> Result<(), Error>

Writes a [char] into this writer, returning whether the write succeeded.

fn write_fmt(&mut self, args: Arguments) -> Result<(), Error>

Glue for usage of the [write!] macro with implementors of this trait.

impl<T: Copy, W: Read<T>, A: Alloc> Read<T> for Write<T, W, A>

Pass-thru

type Err = W::Err

fn read(&mut self, buf: &mut [T]) -> Result<usize, Self::Err>

r.read(buf) = self.readv(&mut [buf])

fn readv(&mut self, bufs: &mut [&mut [T]]) -> Result<usize, Self::Err>

Pull some data, at most bufs.fold(0, |n, buf| n+buf.len()), from this source into given buffers; return how many data were actually read, or a failure. May block if no data can be read when called.

fn size_hint(&self) -> (usize, Option<usize>)

Return bounds on number of data ready to read.

fn read_full<E>(&mut self, buf: &mut [T]) -> Result<(), (E, usize)> where     E: From<Self::Err> + From<EndOfFile>,

Pull buf.len() data from this source into given buffer; return () if so many data were actually read, or a failure and how many data were read before the failure.

fn data(self) -> Data<Self, T>

Make an Iterator over the data of this reader.

fn read_onto_vec<A>(&mut self, xs: &mut Vec<T, A>) -> Result<usize, Self::Err> where     A: Alloc,

Pull data from this source into the spare storage of xs, and modify its length to include the data read. If this fails, xs is unmodified.

fn split<P, E>(self, p: P, keep_delim: bool) -> Split<Self, T, P, E> where     E: From<Self::Err> + From<NoMemory>,     P: FnMut(T) -> bool,