Struct CachingStream 

pub struct CachingStream<R>
where
    R: Read,
{ /* private fields */ }

A wrapper around a Read that buffers and caches the data read in order to support searching with a regex.

Implementations

impl<R> CachingStream<R>

where R: Read,

pub fn new(r: R) -> Self

pub fn clear_until(&self, offset: usize)

Clear the inner gap buffer state up until the end of the line before the given offset, tracking the historic line and byte counts so we can correctly adjust future read offsets.

Data before offset will no longer be accessible.

Trait Implementations

impl<R> Debug for CachingStream<R>

where R: Read + Debug,

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

Formats the value using the given formatter.

impl<R> Edit for CachingStream<R>

where R: Read,

fn insert(&mut self, ix: usize, s: &str)

Insert a string at the specified index

fn remove(&mut self, from: usize, to: usize)

Remove all characters from (from..to)

fn begin_edit_transaction(&mut self)

Mark the start of an edit transaction

fn end_edit_transaction(&mut self)

Mark the end of an edit transaction

impl<R> Haystack<Regex> for CachingStream<R>

where R: Read,

fn is_match_between(&self, re: &Regex, from: usize, to: usize) -> bool

Returns true if there is a match for the regex between the given byte offsets in the haystack.

fn captures_between( &self, re: &Regex, from: usize, to: usize, ) -> Option<RawCaptures>

Searches for the first match of this regex between the given byte offsets in the given haystack, returning the overall match along with the matches of each capture group in the regex. If no match is found, then None is returned.

impl<R> Haystack for CachingStream<R>

where R: Read,

fn try_make_contiguous(&mut self)

fn is_contiguous(&self) -> bool

fn len(&self) -> usize

fn substr_from<'a>(&'a self, byte_offset: usize) -> Option<Cow<'a, str>>

fn substr<'a>(&'a self, byte_from: usize, byte_to: usize) -> Cow<'a, str>

fn byte_to_char(&self, byte_idx: usize) -> Option<usize>

fn char_to_byte(&self, char_idx: usize) -> Option<usize>

fn iter_from(&self, from: usize) -> Option<impl Iterator<Item = (usize, char)>>

fn iter_between( &self, from: usize, to: usize, ) -> impl Iterator<Item = (usize, char)>

fn rev_iter_between( &self, _from: usize, _to: usize, ) -> impl Iterator<Item = (usize, char)>

impl<R> Sliceable for CachingStream<R>

where R: Read,

type Slice<'h> = StreamSlice<'h, R> where Self: 'h

The output of the slice method.

fn char_at(&self, byte_offset: usize) -> Option<char>

Returns the character at the given byte offset if one exists, otherwise None.

fn slice(&self, range: Range<usize>) -> Self::Slice<'_>

The contiguous sub-section of self that is denoted by the given byte Range.

fn max_len(&self) -> usize

The maximum length in bytes.

impl<R> Writable for CachingStream<R>

where R: Read,

fn write_to<W>(&self, w: &mut W) -> Result<usize>

where W: Write,

Writes self to the given io::Write, returning the number of bytes written.