Struct buf::Read

pub struct Read<T, R, A: Alloc> { /* fields omitted */ }

Methods

impl<T, R, A: Alloc + Default> Read<T, R, A>

pub fn with_capacity(r: R, cap: usize) -> Option<Self>

impl<T, R, A: Alloc> Read<T, R, A>

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

pub fn from_raw(r: R, raw: RawVec<T, A>) -> Self

pub fn as_ref(&self) -> &R

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

Trait Implementations

impl<T: Debug, R: Debug, A: Debug + Alloc> Debug for Read<T, R, A>

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

Formats the value using the given formatter.

impl<T: PartialEq, R: PartialEq, A: PartialEq + Alloc> PartialEq for Read<T, R, A>

fn eq(&self, __arg_0: &Read<T, R, A>) -> bool

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

fn ne(&self, __arg_0: &Read<T, R, A>) -> bool

This method tests for !=.

impl<T: Eq, R: Eq, A: Eq + Alloc> Eq for Read<T, R, A>

impl<T: PartialOrd, R: PartialOrd, A: PartialOrd + Alloc> PartialOrd for Read<T, R, A>

fn partial_cmp(&self, __arg_0: &Read<T, R, A>) -> Option<Ordering>

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

fn lt(&self, __arg_0: &Read<T, R, A>) -> bool

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

fn le(&self, __arg_0: &Read<T, R, A>) -> bool

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

fn gt(&self, __arg_0: &Read<T, R, A>) -> bool

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

fn ge(&self, __arg_0: &Read<T, R, A>) -> bool

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

impl<T: Ord, R: Ord, A: Ord + Alloc> Ord for Read<T, R, A>

fn cmp(&self, __arg_0: &Read<T, R, 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, R: Hash, A: Hash + Alloc> Hash for Read<T, R, A>

fn hash<__HTRA: Hasher>(&self, __arg_0: &mut __HTRA)

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, R: Read<T>, A: Alloc> Read<T> for Read<T, R, A>

type Err = R::Err

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

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

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

Return bounds on number of data ready to read.

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 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, 

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

Pass-thru

type Err = R::Err

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

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

fn writev(&mut self, buf: &[&[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 flush(&mut self) -> Result<(), Self::Err>

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.