Struct 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 an error will be returned.

Implementations

impl<Reader: Read> CharacterStream<Reader>

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 lossy(self, is_lossy: bool) -> Self

Kinda builder pattern.

pub fn peeky(self) -> PeekableCharacterStream<Reader, Peek>

Wrap self into a single-peek PeekableCharacterStream.

pub fn peeky_multi(self) -> PeekableCharacterStream<Reader, MultiPeek>

Wrap self into a multi-peek PeekableCharacterStream.

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

Reads a set amount of bytes from the stream.

Set amount 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 read_byte(&mut self) -> Result<u8, CharacterError>

Reads a singluar byte from the stream.

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> CharStream for CharacterStream<Reader>

fn read_char(&mut self) -> CharacterStreamResult

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.

fn is_lossy(&self) -> bool

impl<Reader: Debug + Read> Debug for CharacterStream<Reader>

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

Formats the value using the given formatter.

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, PI> From<CharacterStream<Reader>> for PeekableCharacterStream<Reader, PI>

fn from(stream: CharacterStream<Reader>) -> Self

Converts to this type from the input type.

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

fn from(reader: Reader) -> Self

Converts to this type from the input type.

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

type Item = <<CharacterStream<Reader> as IntoIterator>::IntoIter as Iterator>::Item

The type of the elements being iterated over.

type IntoIter = CharacterIterator<CharacterStream<Reader>>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.