graphml 0.1.1

Streaming GraphML parser producing owned property-graph nodes and edges, with optional Tokio async reading
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58

//! Tokio reader over any `AsyncBufRead` (feature `tokio`).

use quick_xml::Reader;
use quick_xml::events::Event;
use tokio::io::AsyncBufRead;

use crate::error::GraphmlError;
use crate::read::builder::Builder;
use crate::read::record::GraphmlRecord;

/// Async twin of [`GraphmlReader`](crate::GraphmlReader): streams
/// records out of a GraphML document read from a Tokio source, with the
/// same bounded memory.
pub struct AsyncGraphmlReader<R: AsyncBufRead + Unpin> {
    reader: Reader<R>,
    builder: Builder,
    buf: Vec<u8>,
    done: bool,
}

impl<R: AsyncBufRead + Unpin> AsyncGraphmlReader<R> {
    /// Start reading `input`.
    pub fn new(input: R) -> Self {
        let reader = Reader::from_reader(input);
        Self {
            reader,
            builder: Builder::default(),
            buf: Vec::new(),
            done: false,
        }
    }

    /// The next completed record, or `None` at the end of the document.
    ///
    /// # Errors
    ///
    /// Returns [`GraphmlError`] for malformed XML or GraphML.
    pub async fn next_record(&mut self) -> Result<Option<GraphmlRecord>, GraphmlError> {
        while !self.done {
            self.buf.clear();
            let position = self.reader.buffer_position();
            let event = self
                .reader
                .read_event_into_async(&mut self.buf)
                .await
                .map_err(|e| GraphmlError::xml(position, &e))?;
            if matches!(event, Event::Eof) {
                self.done = true;
                self.builder.finish(position)?;
                return Ok(None);
            }
            if let Some(record) = self.builder.handle(&event, position)? {
                return Ok(Some(record));
            }
        }
        Ok(None)
    }
}