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
94
95
96
97
98
99
100
101
102
103
104
105
106

use linked_data::LinkedDataDeserializer;
use rdf_syntax::{Quad, RDF_TYPE};

use crate::{JsonLdIndexed, JsonLdNode};

use super::{deserialize_object, deserialize_object_ref};

pub fn deserialize_node_object<R, D>(
	deserializer: &mut D,
	subject: &R,
	graph: Option<&R>,
) -> Result<JsonLdNode, D::Error>
where
	R: Clone + PartialEq,
	D: LinkedDataDeserializer<R>,
{
	let mut result = JsonLdNode::new_with_id(
		deserialize_resource_id_opt(deserializer, subject)?.map(Into::into),
	);

	// Extract graph.
	if graph.is_none() {
		while let Some(Quad(graph_subject, _, _, _)) =
			deserializer.peek_quad(Quad(Some(subject), None, None, None))?
		{
			let graph_subject = graph_subject.clone();

			result
				.graph
				.get_or_insert_default()
				.insert(JsonLdIndexed::unindexed(deserialize_object(
					deserializer,
					&graph_subject,
					Some(subject),
				)?));
		}
	}

	// Extract properties.
	while let Some(Quad(_, property, object, _)) =
		deserializer.deserialize_quad(Quad(Some(subject), None, None, Some(graph)))?
	{
		let property = deserialize_resource_id(deserializer, &property)?;

		if property == RDF_TYPE {
			result
				.types
				.get_or_insert_default()
				.push_back(deserialize_resource_id(deserializer, &object)?.into());
		}

		result.properties.insert(
			property,
			JsonLdIndexed::unindexed(deserialize_object_ref(deserializer, &object, graph)?),
		);
	}

	Ok(result)
}

pub fn deserialize_node_object_ref<R, D>(
	deserializer: &mut D,
	subject: &R,
) -> Result<JsonLdNode, D::Error>
where
	R: ToOwned,
	D: LinkedDataDeserializer<R>,
{
	Ok(JsonLdNode::new_with_id(
		deserialize_resource_id_opt(deserializer, subject)?.map(Into::into),
	))
}

fn deserialize_resource_id_opt<R, D>(
	deserializer: &mut D,
	subject: &R,
) -> Result<Option<rdf_syntax::Id>, D::Error>
where
	R: ToOwned,
	D: LinkedDataDeserializer<R>,
{
	let mut id = None;

	for term in deserializer.terms_of(subject)? {
		if let Ok(i) = term?.into_id()
			&& let Some(other) = id.replace(i.into_owned())
			&& Some(other) != id
		{
			return Err(linked_data::de::Error::custom("ambiguous id"));
		}
	}

	Ok(id)
}

fn deserialize_resource_id<R, D>(
	deserializer: &mut D,
	subject: &R,
) -> Result<rdf_syntax::Id, D::Error>
where
	R: ToOwned,
	D: LinkedDataDeserializer<R>,
{
	deserialize_resource_id_opt(deserializer, subject)?
		.ok_or_else(|| linked_data::de::Error::custom("missing required id"))
}