Skip to main content

qualia_core_db/sparql_library/serialisers/
rdf_dispatch.rs

1//! Unified zero-heap RDF / RDF-Star serialization dispatch.
2
3use crate::rdf_star::RdfStarSerializer;
4use crate::resolver;
5use crate::sparql_library::parsers::turtle_star::{
6    JsonLdStarSerializer, N3StarSerializer, NQuadsStarSerializer, TrigStarSerializer,
7    TurtleStarSerializer,
8};
9use crate::sparql_library::rdf_formats::{RdfFormat, RdfStarMode};
10use crate::NQuin;
11use std::io::Write;
12
13#[derive(Debug, Clone, PartialEq, Eq)]
14pub enum RdfDispatchError {
15    Unsupported,
16    Io(String),
17}
18
19/// Serializes quins to a writer.
20pub fn serialize_quins<W: Write>(
21    format: RdfFormat,
22    mode: RdfStarMode,
23    quins: &[NQuin],
24    out: &mut W,
25) -> Result<(), RdfDispatchError> {
26    match mode {
27        RdfStarMode::Plain => serialize_plain(format, quins, out),
28        RdfStarMode::Star => serialize_star(format, quins, out),
29    }
30}
31
32fn serialize_plain<W: Write>(
33    format: RdfFormat,
34    quins: &[NQuin],
35    out: &mut W,
36) -> Result<(), RdfDispatchError> {
37    use crate::sparql_library::serialisers::rdf_serializers as ser;
38    // Each format routes to its own serializer. Previously Turtle/N3/JSON-LD/
39    // CBOR-LD all silently emitted N-Triples — a format lie (asking for JSON-LD
40    // yielded N-Triples text). N-Triples/N-Quads keep the zero-heap resolver
41    // fast path; the grouped/structured formats use their real serializers.
42    match format {
43        RdfFormat::NTriples => resolver::format_ntriples_to(quins, out)
44            .map_err(|e| RdfDispatchError::Io(e.to_string())),
45        RdfFormat::NQuads => {
46            resolver::format_nquads_to(quins, out).map_err(|e| RdfDispatchError::Io(e.to_string()))
47        }
48        RdfFormat::Turtle => ser::serialize_to_turtle(out, quins).map_err(RdfDispatchError::Io),
49        RdfFormat::TriG => ser::serialize_to_trig(out, quins).map_err(RdfDispatchError::Io),
50        RdfFormat::N3 => ser::serialize_to_n3(out, quins).map_err(RdfDispatchError::Io),
51        RdfFormat::JsonLd => ser::serialize_to_jsonld(out, quins).map_err(RdfDispatchError::Io),
52        RdfFormat::CborLd => ser::serialize_to_cborld(out, quins).map_err(RdfDispatchError::Io),
53    }
54}
55
56fn serialize_star<W: Write>(
57    format: RdfFormat,
58    quins: &[NQuin],
59    out: &mut W,
60) -> Result<(), RdfDispatchError> {
61    match format {
62        RdfFormat::NTriples => resolver::format_ntriples_star_to(quins, out)
63            .map_err(|e| RdfDispatchError::Io(e.to_string())),
64        RdfFormat::NQuads => {
65            for q in quins {
66                let ser = NQuadsStarSerializer::new();
67                let bytes = if q.context != 0 {
68                    ser.serialize_quad(q.subject, q.predicate, q.object, q.context)
69                } else {
70                    ser.serialize_triple(q.subject, q.predicate, q.object)
71                }
72                .map_err(|e| RdfDispatchError::Io(format!("{e:?}")))?;
73                out.write_all(&bytes)
74                    .map_err(|e| RdfDispatchError::Io(e.to_string()))?;
75                out.write_all(b"\n")
76                    .map_err(|e| RdfDispatchError::Io(e.to_string()))?;
77            }
78            Ok(())
79        }
80        RdfFormat::Turtle => write_with_serializer(quins, out, &TurtleStarSerializer::new()),
81        RdfFormat::TriG => {
82            let ser = TrigStarSerializer::new();
83            write_with_serializer(quins, out, &ser)
84        }
85        RdfFormat::N3 => {
86            let ser = N3StarSerializer::new();
87            write_with_serializer(quins, out, &ser)
88        }
89        RdfFormat::JsonLd => {
90            let ser = JsonLdStarSerializer::new();
91            write_with_serializer(quins, out, &ser)
92        }
93        RdfFormat::CborLd => Err(RdfDispatchError::Unsupported),
94    }
95}
96
97fn write_with_serializer<W: Write, S: RdfStarSerializer>(
98    quins: &[NQuin],
99    out: &mut W,
100    ser: &S,
101) -> Result<(), RdfDispatchError> {
102    for q in quins {
103        let bytes = if q.context != 0 && ser.supports_quads() {
104            ser.serialize_quad(q.subject, q.predicate, q.object, q.context)
105        } else {
106            ser.serialize_triple(q.subject, q.predicate, q.object)
107        }
108        .map_err(|e| RdfDispatchError::Io(format!("{e:?}")))?;
109        out.write_all(&bytes)
110            .map_err(|e| RdfDispatchError::Io(e.to_string()))?;
111        out.write_all(b"\n")
112            .map_err(|e| RdfDispatchError::Io(e.to_string()))?;
113    }
114    Ok(())
115}