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
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93

use linked_data::{
	LinkedDataSerializer, SerializeLinkedData,
	ser::{IdSerializer, SerializeLinkedDataWith},
};
use rdf_syntax::{RDF_TYPE, Term};

use crate::{JsonLdLenient, JsonLdNode};

use super::super::RdfSerializationOptions;

impl SerializeLinkedDataWith<RdfSerializationOptions> for JsonLdNode {
	fn serialize_rdf_with<S>(
		&self,
		opts: RdfSerializationOptions,
		mut serializer: S,
		graph: Option<&Term>,
	) -> Result<S::Ok, S::Error>
	where
		S: LinkedDataSerializer<Term>,
	{
		let subject = match &self.id {
			Some(JsonLdLenient::Valid(id)) => id.clone().into(),
			Some(JsonLdLenient::Invalid(_)) => return serializer.end(),
			None => serializer.interpret(None)?,
		};

		if let Some(types) = &self.types
			&& !types.is_empty()
		{
			let predicate = Term::iri(RDF_TYPE.to_owned());
			types.serialize_rdf_objects(&mut serializer, &subject, &predicate, graph)?;
		}

		for (id, objects) in self.properties() {
			let property = id.serialize_rdf_term(&mut serializer)?;
			if !opts.produce_generalized_rdf && !property.is_iri() {
				continue;
			}
			for obj in objects {
				obj.serialize_rdf_objects_with(
					opts.clone(),
					serializer.as_dyn_mut(),
					&subject,
					&property,
					graph,
				)?;
			}
		}

		if let Some(reverse) = self.reverse_properties() {
			for (id, subjects) in reverse {
				let property = id.serialize_rdf_term(&mut serializer)?;
				if !opts.produce_generalized_rdf && !property.is_iri() {
					continue;
				}
				for rev_subject in subjects {
					let rev_subject = match rev_subject
						.serialize_rdf(IdSerializer::new(serializer.as_dyn_mut()), graph)?
					{
						Some(s) => s,
						None => serializer.interpret(None)?,
					};
					subject.serialize_rdf_objects(
						serializer.as_dyn_mut(),
						&rev_subject,
						&property,
						graph,
					)?;
				}
			}
		}

		self.graph.serialize_rdf_graph_with(
			opts.clone(),
			serializer.as_dyn_mut(),
			Some(&subject),
		)?;

		serializer.serialize_resource(Some(subject))?;

		self.included
			.serialize_rdf_graph_with(opts, serializer, graph)
	}
}

impl SerializeLinkedData for JsonLdNode {
	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)
	}
}