Struct vectorscan::stream::StreamWriter

pub struct StreamWriter<'code> {
    pub inner: ScratchStreamSink<'code>,
    /* private fields */
}

Available on crate feature stream only.

A wrapper over ScratchStreamSink which implements io::Write.

The reason this is separate from ScratchStreamSink is that in the case of vectored writes, io::IoSlice must be converted into VectoredByteSlices. This would typically require a dynamic memory allocation, but this struct maintains an internal buffer of strings which is re-used for subsequent vectored writes to avoid repeated dynamic memory allocation. This buffer isn’t needed except for compatibility with the io::IoSlice API.

 #[cfg(feature = "compiler")]
 fn main() -> Result<(), vectorscan::error::VectorscanError> {
   use vectorscan::{expression::*, flags::*, stream::*, matchers::*};
   use std::{ops::Range, io::Write};

   let expr: Expression = "a+".parse()?;
   let db = expr.compile(Flags::SOM_LEFTMOST, Mode::STREAM | Mode::SOM_HORIZON_LARGE)?;
   let scratch = db.allocate_scratch()?;
   let live = db.allocate_stream()?;

   let mut matches: Vec<StreamMatch> = Vec::new();
   let mut match_fn = |m| {
     matches.push(m);
     MatchResult::Continue
   };
   // Create a scope to mutably borrow `matches` in via `match_fn`:
   {
     let matcher = StreamMatcher::new(&mut match_fn);
     let sink = ScratchStreamSink::new(live, matcher, scratch);
     let mut sink = StreamWriter::new(sink);

     sink.write_all(b"aardvark").unwrap();
     // No analogy for tokio's .shutdown(), but we still
     // need to explicitly mark end-of-data:
     sink.inner.flush_eod()?;
   }
   // After `sink` (and therefore `matcher`) was dropped,
   // we can access the closed-over data again!
   let matches: Vec<Range<usize>> = matches
     .into_iter()
     .map(|m| m.range.into())
     .collect();
   assert_eq!(&matches, &[0..1, 0..2, 5..6]);
   Ok(())
 }

Fields

inner: ScratchStreamSink<'code>

Implementations

impl<'code> StreamWriter<'code>

pub fn new(inner: ScratchStreamSink<'code>) -> Self

Construct a wrapper over inner.

Trait Implementations

impl<'code> Write for StreamWriter<'code>

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

Write a buffer into this writer, returning how many bytes were written.

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

Flush this output stream, ensuring that all intermediately buffered contents reach their destination.

fn write_vectored(&mut self, bufs: &[IoSlice<'_>]) -> Result<usize>

Like write, except that it writes from a slice of buffers.

fn is_write_vectored(&self) -> bool

🔬This is a nightly-only experimental API. (can_vector)

Determines if this Writer has an efficient write_vectored implementation.

fn write_all(&mut self, buf: &[u8]) -> Result<(), Error>

Attempts to write an entire buffer into this writer.

fn write_all_vectored(&mut self, bufs: &mut [IoSlice<'_>]) -> Result<(), Error>

🔬This is a nightly-only experimental API. (write_all_vectored)

Attempts to write multiple buffers into this writer.

fn write_fmt(&mut self, fmt: Arguments<'_>) -> Result<(), Error>

Writes a formatted string into this writer, returning any error encountered.

fn by_ref(&mut self) -> &mut Self

where Self: Sized,

Creates a “by reference” adapter for this instance of Write.