json-ld 0.22.0

JSON-LD implementation
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
59
60
61
62
63
64

use linked_data::{LinkedDataSerializer, SerializeLinkedData, ser::SerializeLinkedDataWith};
use rdf_syntax::{RDF_FIRST, RDF_NIL, RDF_REST, Term};

use crate::{JsonLdIndexedObject, object::JsonLdList};

use super::super::RdfSerializationOptions;

impl SerializeLinkedDataWith<RdfSerializationOptions> for JsonLdList {
	fn serialize_rdf_with<S>(
		&self,
		opts: RdfSerializationOptions,
		serializer: S,
		graph: Option<&Term>,
	) -> Result<S::Ok, S::Error>
	where
		S: LinkedDataSerializer<Term>,
	{
		RestWith(self.as_slice(), opts).serialize_rdf(serializer, graph)
	}
}

impl SerializeLinkedData for JsonLdList {
	fn serialize_rdf<S>(&self, serializer: S, graph: Option<&Term>) -> Result<S::Ok, S::Error>
	where
		S: LinkedDataSerializer<Term>,
	{
		self.serialize_rdf_with(RdfSerializationOptions::default(), serializer, graph)
	}
}

struct RestWith<'a>(&'a [JsonLdIndexedObject], RdfSerializationOptions);

impl SerializeLinkedData for RestWith<'_> {
	fn serialize_rdf<S>(&self, mut serializer: S, graph: Option<&Term>) -> Result<S::Ok, S::Error>
	where
		S: LinkedDataSerializer<Term>,
	{
		let node = match self.0.split_first() {
			Some((first, rest)) => {
				let subject = serializer.interpret(None)?;
				let predicate = Term::iri(RDF_FIRST.to_owned());
				first.serialize_rdf_objects_with(
					self.1.clone(),
					serializer.as_dyn_mut(),
					&subject,
					&predicate,
					graph,
				)?;
				let predicate = Term::iri(RDF_REST.to_owned());
				RestWith(rest, self.1.clone()).serialize_rdf_objects(
					serializer.as_dyn_mut(),
					&subject,
					&predicate,
					graph,
				)?;
				subject
			}
			None => Term::iri(RDF_NIL.to_owned()),
		};

		serializer.serialize_resource(Some(node))?;
		serializer.end()
	}
}