Struct character_stream::CharacterStream

pub struct CharacterStream<Reader: Read> {
    pub stream: Reader,
    pub is_lossy: bool,
}

Wrapper struct for any stream that implements BufRead and Seek.

It allows you to read in bytes from a stream, and attempt to parse them into characters.

These bytes however, must be valid UTF-8 code points.

This wrapper does NOT parse graphemes.

Fields

stream: Reader

The stream from which the incoming bytes are from.

is_lossy: bool

Whether or not we should care whether invalid bytes are detected.

If true, then invalid byte sequences will be replaced with a U+FFFD.

If false, then Failure will be the returned result.

Implementations

impl<Reader: Read> CharacterStream<Reader>

pub fn from(stream: Reader) -> Self

Create a CharacterStream from a stream.

The created CharacterStream will not be lossy.

pub fn new(stream: Reader, is_lossy: bool) -> Self

Create a CharacterStream from a stream.

Set is_lossy to true if you don’t want to handle invalid byte sequences.

pub fn read_bytes(&mut self, up_to: usize) -> Result<Vec<u8>, IoError>

Reads a set amount of bytes from the stream.

Set up_to to the amount of bytes you would like to read.

Upon success, a Vec<u8> is returned, holding the read bytes.

Upon failure, an error is returned.

pub fn peek_bytes(&mut self, up_to: usize) -> Result<Vec<u8>, IoError> where
    Reader: Seek, 

Does exactly what read_bytes performs, the difference being it seeks back to the position before the read, serving as a lookahead function.

pub fn read_byte(&mut self) -> Result<u8, IoError>

Reads a singluar byte from the stream.

pub fn peek_byte(&mut self) -> Result<u8, IoError> where
    Reader: Seek, 

Does exactly what read_byte performs, the difference being it seeks back to the position before the read, serving as a lookahead function.

pub fn read_char(&mut self) -> Result<CharacterStreamResult, IoError>

Attempts to read a character from the stream.

If is_lossy is set to true, then invalid byte sequences will be a U+FFFD.

If is_lossy is set to false, then invalid byte sequences will be returned in addition to a parse error.

pub fn peek_char(&mut self) -> Result<CharacterStreamResult, IoError> where
    Reader: Seek, 

Performs the same action as read_char, the difference being, it seeks back to the position prior to the read.

Trait Implementations

impl<Reader: Read> AsMut<Reader> for CharacterStream<Reader>

fn as_mut(&mut self) -> &mut Reader

Converts this type into a mutable reference of the (usually inferred) input type.

impl<Reader: Read> AsRef<Reader> for CharacterStream<Reader>

fn as_ref(&self) -> &Reader

Converts this type into a shared reference of the (usually inferred) input type.

impl<Reader: Read> Deref for CharacterStream<Reader>

type Target = Reader

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<Reader: Read> DerefMut for CharacterStream<Reader>

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

impl<Reader: Read> IntoIterator for CharacterStream<Reader>

type Item = Result<char, CharacterStreamError>

The type of the elements being iterated over.

type IntoIter = CharacterIterator<Reader>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.