Struct AsyncStreamingParser 

pub struct AsyncStreamingParser { /* private fields */ }

Async RDF streaming parser for high-performance large file processing

See the module-level docs for which formats are genuinely streamed (N-Triples/N-Quads) versus buffered-then-parsed (everything else).

Implementations

impl AsyncStreamingParser

pub fn new(format: RdfFormat) -> Self

Create a new async streaming parser

pub fn with_progress_callback<F>(self, callback: F) -> Self

where F: Fn(usize) + Send + Sync + 'static,

Set a progress callback that reports the number of bytes processed

pub fn with_chunk_size(self, chunk_size: usize) -> Self

Set the chunk size for streaming processing

pub fn with_max_buffer_size(self, max_buffer_size: usize) -> Self

Set the maximum number of bytes this parser will accumulate in memory before returning an error, for formats that are not incrementally streamed (anything other than N-Triples/N-Quads; see module docs). Has no effect on N-Triples/N-Quads, which always stream with bounded per-chunk memory regardless of document size.

pub fn with_error_tolerance(self, ignore_errors: bool) -> Self

Configure error tolerance

pub async fn parse_stream<R, F, Fut>(&self, reader: R, handler: F) -> Result<()>

where R: AsyncRead + Unpin, F: FnMut(Quad) -> Fut, Fut: Future<Output = Result<()>>,

Parse from an async readable stream

pub async fn parse_bytes<F, Fut>(&self, data: &[u8], handler: F) -> Result<()>

where F: FnMut(Quad) -> Fut, Fut: Future<Output = Result<()>>,

Parse from bytes asynchronously

pub async fn parse_str_async<F, Fut>( &self, data: &str, handler: F, ) -> Result<()>

where F: FnMut(Quad) -> Fut, Fut: Future<Output = Result<()>>,

Parse from string asynchronously

pub async fn parse_str_to_quads_async(&self, data: &str) -> Result<Vec<Quad>>

Convenience method to parse to a vector asynchronously