1use rdf_syntax::{
2 BlankId, BlankIdBuf, CowTerm, GroundTerm, Id, Iri, IriBuf, Literal, LiteralRef, Quad,
3 RDF_FIRST, RDF_NIL, RDF_REST, Term,
4};
5
6mod flatten;
7mod id;
8mod properties;
9mod quads;
10mod unordered;
11
12pub use flatten::*;
13pub use id::*;
14pub use properties::*;
15pub use quads::*;
16pub use unordered::*;
17
18pub trait SerializeLinkedDataWith<Q, R: Clone + Ord = Term> {
19 fn serialize_rdf_with<S>(
20 &self,
21 state: Q,
22 serializer: S,
23 graph: Option<&R>,
24 ) -> Result<S::Ok, S::Error>
25 where
26 S: LinkedDataSerializer<R>;
27
28 fn serialize_rdf_subjects_with<S>(
29 &self,
30 state: Q,
31 serializer: S,
32 predicate: &R,
33 object: &R,
34 graph: Option<&R>,
35 ) -> Result<S::Ok, S::Error>
36 where
37 S: LinkedDataSerializer<R>,
38 {
39 self.serialize_rdf_with(
40 state,
41 SubjectsSerializer {
42 serializer,
43 predicate,
44 object,
45 graph,
46 },
47 graph,
48 )
49 }
50
51 fn serialize_rdf_objects_with<S>(
52 &self,
53 state: Q,
54 serializer: S,
55 subject: &R,
56 predicate: &R,
57 graph: Option<&R>,
58 ) -> Result<S::Ok, S::Error>
59 where
60 S: LinkedDataSerializer<R>,
61 {
62 self.serialize_rdf_with(
63 state,
64 ObjectsSerializer {
65 serializer,
66 subject,
67 predicate,
68 graph,
69 },
70 graph,
71 )
72 }
73
74 fn serialize_rdf_graph_with<S>(
76 &self,
77 state: Q,
78 serializer: S,
79 graph: Option<&R>,
80 ) -> Result<S::Ok, S::Error>
81 where
82 S: LinkedDataSerializer<R>,
83 {
84 self.serialize_rdf_with(state, GraphSerializer { serializer }, graph)
85 }
86}
87
88pub trait SerializeLinkedData<R: Clone + Ord = Term> {
89 fn serialize_rdf<S>(&self, serializer: S, graph: Option<&R>) -> Result<S::Ok, S::Error>
90 where
91 S: LinkedDataSerializer<R>;
92
93 fn serialize_rdf_subjects<S>(
94 &self,
95 serializer: S,
96 predicate: &R,
97 object: &R,
98 graph: Option<&R>,
99 ) -> Result<S::Ok, S::Error>
100 where
101 S: LinkedDataSerializer<R>,
102 {
103 self.serialize_rdf(
104 SubjectsSerializer {
105 serializer,
106 predicate,
107 object,
108 graph,
109 },
110 graph,
111 )
112 }
113
114 fn serialize_rdf_objects<S>(
115 &self,
116 serializer: S,
117 subject: &R,
118 predicate: &R,
119 graph: Option<&R>,
120 ) -> Result<S::Ok, S::Error>
121 where
122 S: LinkedDataSerializer<R>,
123 {
124 self.serialize_rdf(
125 ObjectsSerializer {
126 serializer,
127 subject,
128 predicate,
129 graph,
130 },
131 graph,
132 )
133 }
134
135 fn serialize_rdf_graph<S>(&self, serializer: S, graph: Option<&R>) -> Result<S::Ok, S::Error>
137 where
138 S: LinkedDataSerializer<R>,
139 {
140 self.serialize_rdf(GraphSerializer { serializer }, graph)
141 }
142}
143
144struct SubjectsSerializer<'a, R, S> {
145 serializer: S,
146 predicate: &'a R,
147 object: &'a R,
148 graph: Option<&'a R>,
149}
150
151impl<'a, R: Clone + Ord, S: LinkedDataSerializer<R>> LinkedDataSerializer<R>
152 for SubjectsSerializer<'a, R, S>
153{
154 type Ok = S::Ok;
155 type Error = S::Error;
156
157 fn interpret(&mut self, term: Option<CowTerm>) -> Result<R, Self::Error> {
158 self.serializer.interpret(term)
159 }
160
161 fn serialize_resource(&mut self, subject: Option<R>) -> Result<R, Self::Error> {
162 let subject = match subject {
163 Some(s) => s,
164 None => self.interpret(None)?,
165 };
166
167 self.serializer.serialize_quad(Quad(
168 subject.clone(),
169 self.predicate.clone(),
170 self.object.clone(),
171 self.graph.cloned(),
172 ))?;
173
174 Ok(subject)
175 }
176
177 fn serialize_quad(&mut self, quad: Quad<R>) -> Result<(), Self::Error> {
178 self.serializer.serialize_quad(quad)
179 }
180
181 fn end(self) -> Result<Self::Ok, Self::Error> {
182 self.serializer.end()
183 }
184}
185
186struct ObjectsSerializer<'a, R, S> {
187 serializer: S,
188 subject: &'a R,
189 predicate: &'a R,
190 graph: Option<&'a R>,
191}
192
193impl<'a, R: Clone + Ord, S: LinkedDataSerializer<R>> LinkedDataSerializer<R>
194 for ObjectsSerializer<'a, R, S>
195{
196 type Ok = S::Ok;
197 type Error = S::Error;
198
199 fn interpret(&mut self, term: Option<CowTerm>) -> Result<R, Self::Error> {
200 self.serializer.interpret(term)
201 }
202
203 fn serialize_resource(&mut self, object: Option<R>) -> Result<R, Self::Error> {
204 let object = match object {
205 Some(o) => o,
206 None => self.interpret(None)?,
207 };
208
209 self.serializer.serialize_quad(Quad(
210 self.subject.clone(),
211 self.predicate.clone(),
212 object.clone(),
213 self.graph.cloned(),
214 ))?;
215
216 Ok(object)
217 }
218
219 fn serialize_quad(&mut self, quad: Quad<R>) -> Result<(), Self::Error> {
220 self.serializer.serialize_quad(quad)
221 }
222
223 fn end(self) -> Result<Self::Ok, Self::Error> {
224 self.serializer.end()
225 }
226}
227
228struct GraphSerializer<S> {
229 serializer: S,
230}
231
232impl<R: Clone + Ord, S: LinkedDataSerializer<R>> LinkedDataSerializer<R> for GraphSerializer<S> {
233 type Ok = S::Ok;
234 type Error = S::Error;
235
236 fn interpret(&mut self, term: Option<CowTerm>) -> Result<R, Self::Error> {
237 self.serializer.interpret(term)
238 }
239
240 fn serialize_resource(&mut self, object: Option<R>) -> Result<R, Self::Error> {
241 match object {
242 Some(o) => Ok(o),
243 None => self.interpret(None),
244 }
245 }
246
247 fn serialize_quad(&mut self, quad: Quad<R>) -> Result<(), Self::Error> {
248 self.serializer.serialize_quad(quad)
249 }
250
251 fn end(self) -> Result<Self::Ok, Self::Error> {
252 self.serializer.end()
253 }
254}
255
256impl<Q, R: Clone + Ord, T: SerializeLinkedDataWith<Q, R>> SerializeLinkedDataWith<Q, R> for &T {
257 fn serialize_rdf_with<S>(
258 &self,
259 state: Q,
260 serializer: S,
261 graph: Option<&R>,
262 ) -> Result<S::Ok, S::Error>
263 where
264 S: LinkedDataSerializer<R>,
265 {
266 T::serialize_rdf_with(*self, state, serializer, graph)
267 }
268}
269
270impl<R: Clone + Ord, T: SerializeLinkedData<R>> SerializeLinkedData<R> for &T {
271 fn serialize_rdf<S>(&self, serializer: S, graph: Option<&R>) -> Result<S::Ok, S::Error>
272 where
273 S: LinkedDataSerializer<R>,
274 {
275 T::serialize_rdf(*self, serializer, graph)
276 }
277}
278
279impl<Q, R: Clone + Ord, T: SerializeLinkedDataWith<Q, R>> SerializeLinkedDataWith<Q, R>
280 for Option<T>
281{
282 fn serialize_rdf_with<S>(
283 &self,
284 state: Q,
285 serializer: S,
286 graph: Option<&R>,
287 ) -> Result<S::Ok, S::Error>
288 where
289 S: LinkedDataSerializer<R>,
290 {
291 match self {
292 Some(t) => t.serialize_rdf_with(state, serializer, graph),
293 None => serializer.end(),
294 }
295 }
296}
297
298impl<R: Clone + Ord, T: SerializeLinkedData<R>> SerializeLinkedData<R> for Option<T> {
299 fn serialize_rdf<S>(&self, serializer: S, graph: Option<&R>) -> Result<S::Ok, S::Error>
300 where
301 S: LinkedDataSerializer<R>,
302 {
303 match self {
304 Some(t) => t.serialize_rdf(serializer, graph),
305 None => serializer.end(),
306 }
307 }
308}
309
310impl<R: Clone + Ord> SerializeLinkedData<R> for Iri {
311 fn serialize_rdf<S>(&self, mut serializer: S, _graph: Option<&R>) -> Result<S::Ok, S::Error>
312 where
313 S: LinkedDataSerializer<R>,
314 {
315 let this = serializer.interpret(Some(self.into()))?;
316 serializer.serialize_resource(Some(this))?;
317 serializer.end()
318 }
319}
320
321impl<R: Clone + Ord> SerializeLinkedData<R> for IriBuf {
322 fn serialize_rdf<S>(&self, serializer: S, graph: Option<&R>) -> Result<S::Ok, S::Error>
323 where
324 S: LinkedDataSerializer<R>,
325 {
326 self.as_iri().serialize_rdf(serializer, graph)
327 }
328}
329
330impl<R: Clone + Ord> SerializeLinkedData<R> for BlankId {
331 fn serialize_rdf<S>(&self, mut serializer: S, _graph: Option<&R>) -> Result<S::Ok, S::Error>
332 where
333 S: LinkedDataSerializer<R>,
334 {
335 let this = serializer.interpret(Some(self.into()))?;
336 serializer.serialize_resource(Some(this))?;
337 serializer.end()
338 }
339}
340
341impl<R: Clone + Ord> SerializeLinkedData<R> for BlankIdBuf {
342 fn serialize_rdf<S>(&self, serializer: S, graph: Option<&R>) -> Result<S::Ok, S::Error>
343 where
344 S: LinkedDataSerializer<R>,
345 {
346 self.as_blank_id().serialize_rdf(serializer, graph)
347 }
348}
349
350impl<R: Clone + Ord> SerializeLinkedData<R> for Id {
351 fn serialize_rdf<S>(&self, mut serializer: S, _graph: Option<&R>) -> Result<S::Ok, S::Error>
352 where
353 S: LinkedDataSerializer<R>,
354 {
355 let this = serializer.interpret(Some(self.into()))?;
356 serializer.serialize_resource(Some(this))?;
357 serializer.end()
358 }
359}
360
361impl<R: Clone + Ord> SerializeLinkedData<R> for Literal {
362 fn serialize_rdf<S>(&self, mut serializer: S, _graph: Option<&R>) -> Result<S::Ok, S::Error>
363 where
364 S: LinkedDataSerializer<R>,
365 {
366 let this = serializer.interpret(Some(self.into()))?;
367 serializer.serialize_resource(Some(this))?;
368 serializer.end()
369 }
370}
371
372impl<R: Clone + Ord> SerializeLinkedData<R> for LiteralRef<'_> {
373 fn serialize_rdf<S>(&self, mut serializer: S, _graph: Option<&R>) -> Result<S::Ok, S::Error>
374 where
375 S: LinkedDataSerializer<R>,
376 {
377 let this = serializer.interpret(Some((*self).into()))?;
378 serializer.serialize_resource(Some(this))?;
379 serializer.end()
380 }
381}
382
383impl<R: Clone + Ord> SerializeLinkedData<R> for GroundTerm {
384 fn serialize_rdf<S>(&self, mut serializer: S, _graph: Option<&R>) -> Result<S::Ok, S::Error>
385 where
386 S: LinkedDataSerializer<R>,
387 {
388 let this = serializer.interpret(Some(self.clone().into()))?;
389 serializer.serialize_resource(Some(this))?;
390 serializer.end()
391 }
392}
393
394impl<R: Clone + Ord> SerializeLinkedData<R> for Term {
395 fn serialize_rdf<S>(&self, mut serializer: S, _graph: Option<&R>) -> Result<S::Ok, S::Error>
396 where
397 S: LinkedDataSerializer<R>,
398 {
399 let this = serializer.interpret(Some(self.clone().into()))?;
400 serializer.serialize_resource(Some(this))?;
401 serializer.end()
402 }
403}
404
405impl<Q: Clone, R: Clone + Ord, T: SerializeLinkedDataWith<Q, R>> SerializeLinkedDataWith<Q, R>
406 for [T]
407{
408 fn serialize_rdf_with<S>(
409 &self,
410 state: Q,
411 mut serializer: S,
412 graph: Option<&R>,
413 ) -> Result<S::Ok, S::Error>
414 where
415 S: LinkedDataSerializer<R>,
416 {
417 let prop_first = serializer.interpret(Some(RDF_FIRST.into()))?;
418 let prop_rest = serializer.interpret(Some(RDF_REST.into()))?;
419
420 let head = if self.is_empty() {
421 Some(serializer.interpret(Some(RDF_NIL.into()))?)
422 } else {
423 None
424 };
425
426 let mut head = serializer.serialize_resource(head)?;
427
428 for (i, value) in self.iter().enumerate() {
429 value.serialize_rdf_objects_with(
430 state.clone(),
431 serializer.as_dyn_mut(),
432 &head,
433 &prop_first,
434 graph,
435 )?;
436
437 let rest_term = if i + 1 < self.len() {
438 None
439 } else {
440 Some(RDF_NIL.into())
441 };
442
443 let rest = serializer.interpret(rest_term)?;
444
445 serializer.serialize_quad(Quad(
446 head,
447 prop_rest.clone(),
448 rest.clone(),
449 graph.cloned(),
450 ))?;
451
452 head = rest;
453 }
454
455 serializer.end()
456 }
457}
458
459impl<R: Clone + Ord, T: SerializeLinkedData<R>> SerializeLinkedData<R> for [T] {
460 fn serialize_rdf<S>(&self, mut serializer: S, graph: Option<&R>) -> Result<S::Ok, S::Error>
461 where
462 S: LinkedDataSerializer<R>,
463 {
464 let prop_first = serializer.interpret(Some(RDF_FIRST.into()))?;
465 let prop_rest = serializer.interpret(Some(RDF_REST.into()))?;
466
467 let head = if self.is_empty() {
468 Some(serializer.interpret(Some(RDF_NIL.into()))?)
469 } else {
470 None
471 };
472
473 let mut head = serializer.serialize_resource(head)?;
474
475 for (i, value) in self.iter().enumerate() {
476 value.serialize_rdf_objects(serializer.as_dyn_mut(), &head, &prop_first, graph)?;
477
478 let rest_term = if i + 1 < self.len() {
479 None
480 } else {
481 Some(RDF_NIL.into())
482 };
483
484 let rest = serializer.interpret(rest_term)?;
485
486 serializer.serialize_quad(Quad(
487 head,
488 prop_rest.clone(),
489 rest.clone(),
490 graph.cloned(),
491 ))?;
492
493 head = rest;
494 }
495
496 serializer.end()
497 }
498}
499
500impl<Q: Clone, R: Clone + Ord, T: SerializeLinkedDataWith<Q, R>> SerializeLinkedDataWith<Q, R>
501 for Vec<T>
502{
503 fn serialize_rdf_with<S>(
504 &self,
505 state: Q,
506 serializer: S,
507 graph: Option<&R>,
508 ) -> Result<S::Ok, S::Error>
509 where
510 S: LinkedDataSerializer<R>,
511 {
512 self.as_slice().serialize_rdf_with(state, serializer, graph)
513 }
514}
515
516impl<R: Clone + Ord, T: SerializeLinkedData<R>> SerializeLinkedData<R> for Vec<T> {
517 fn serialize_rdf<S>(&self, serializer: S, graph: Option<&R>) -> Result<S::Ok, S::Error>
518 where
519 S: LinkedDataSerializer<R>,
520 {
521 self.as_slice().serialize_rdf(serializer, graph)
522 }
523}
524
525impl<R: Clone + Ord> SerializeLinkedData<R> for String {
526 fn serialize_rdf<S>(&self, mut serializer: S, _graph: Option<&R>) -> Result<S::Ok, S::Error>
527 where
528 S: LinkedDataSerializer<R>,
529 {
530 let this = serializer.interpret(Some(self.into()))?;
531 serializer.serialize_resource(Some(this))?;
532 serializer.end()
533 }
534}
535
536pub trait LinkedDataSerializer<R: Clone + Ord = Term> {
537 type Ok;
538 type Error: Error<R>;
539
540 fn as_dyn_mut(&mut self) -> &mut dyn LinkedDataSerializer<R, Ok = Self::Ok, Error = Self::Error>
541 where
542 Self: Sized,
543 {
544 self
545 }
546
547 fn interpret(&mut self, term: Option<CowTerm>) -> Result<R, Self::Error>;
548
549 fn serialize_resource(&mut self, resource: Option<R>) -> Result<R, Self::Error>;
550
551 fn serialize_quad(&mut self, quad: Quad<R>) -> Result<(), Self::Error>;
552
553 fn end(self) -> Result<Self::Ok, Self::Error>;
554}
555
556impl<R: Clone + Ord, S: ?Sized + LinkedDataSerializer<R>> LinkedDataSerializer<R> for &mut S {
557 type Ok = ();
558 type Error = S::Error;
559
560 fn interpret(&mut self, term: Option<CowTerm>) -> Result<R, Self::Error> {
561 S::interpret(*self, term)
562 }
563
564 fn serialize_resource(&mut self, resource: Option<R>) -> Result<R, Self::Error> {
565 S::serialize_resource(*self, resource)
566 }
567
568 fn serialize_quad(&mut self, quad: Quad<R>) -> Result<(), Self::Error> {
569 S::serialize_quad(*self, quad)
570 }
571
572 fn end(self) -> Result<Self::Ok, Self::Error> {
573 Ok(())
574 }
575}
576
577pub trait Error<R>: Sized {
578 fn custom(str: impl ToString) -> Self;
579
580 fn ambiguous_resource(_r: &R) -> Self {
581 Self::custom("ambiguous resouce")
582 }
583}