Struct io::Pos

pub struct Pos<T> {
    pub pos: usize,
    // some fields omitted
}

Fields

pos: usize

Implementations

impl<T> Pos<T>

pub fn unwrap(self) -> T

Trait Implementations

impl<T: Clone> Clone for Pos<T>

fn clone(&self) -> Pos<T>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T: Copy> Copy for Pos<T>

impl<T: Debug> Debug for Pos<T>

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

Formats the value using the given formatter.

impl<T: Eq> Eq for Pos<T>

impl<T> From<T> for Pos<T>

fn from(x: T) -> Self

Performs the conversion.

impl<T: Hash> Hash for Pos<T>

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

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: PartialEq> PartialEq<Pos<T>> for Pos<T>

fn eq(&self, other: &Pos<T>) -> bool

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

fn ne(&self, other: &Pos<T>) -> bool

This method tests for !=.

impl<S: Copy, T: Deref<Target = [S]>> Read<S> for Pos<T>

type Err = Void

fn read(&mut self, buf: &mut [S]) -> Result<usize, Void>

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 try_read_full(&mut self, buf: &mut [T]) -> Result<usize, (Self::Err, usize)>

Pull buf.len() data from this source into given buffer; return how many data were actually read (which may be less than buf.len() if we reached end-of-file), or a failure and how many data were read before the failure.

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

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 size_hint(&self) -> (usize, Option<usize>)

Return bounds on number of data ready to read.

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

Important traits for Data<R, T>

impl<R: Read<T>, T: Copy> Iterator for Data<R, T> type Item = Result<T, R::Err>;

where
    Self: Sized, 

Make an Iterator over the data of this reader.

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

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: FnMut(T) -> bool, E: From<Self::Err> + From<NoMemory>>(
    self,
    p: P,
    keep_delim: bool
) -> Split<Self, T, P, E>ⓘ

Important traits for Split<R, T, P, E>

impl<R: Read<T>, T: Copy, P: FnMut(T) -> bool, E: From<R::Err> + From<NoMemory>> Iterator for Split<R, T, P, E> type Item = Result<Vec<T>, E>;

where
    Self: Sized, 

impl<T> StructuralEq for Pos<T>

impl<T> StructuralPartialEq for Pos<T>

impl<S: Copy, T: DerefMut<Target = [S]>> Write<S> for Pos<T>

type Err = Void

fn write(&mut self, buf: &[S]) -> Result<usize, Void>

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

fn flush(&mut self) -> Result<(), Void>

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.

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

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<T: DerefMut<Target = [u8]>> Write for Pos<T>

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

Writes a string slice 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.