rdf_types/interpretation/
term.rs

1use iref::Iri;
2
3use crate::{
4	vocabulary::{BlankIdVocabulary, IriVocabulary},
5	BlankId, Generator, Id, Literal, LiteralRef, Quad, Term, Vocabulary, VocabularyMut,
6};
7
8use super::{
9	IdInterpretation, IdInterpretationMut, IdsOf, LiteralInterpretation, LiteralInterpretationMut,
10	ReverseBlankIdInterpretation, ReverseIdInterpretation, ReverseIdInterpretationMut,
11	ReverseIriInterpretation, ReverseLiteralInterpretation, TraversableInterpretation,
12	UninterpretedGrdfQuadRef, UninterpretedTermRef,
13};
14
15/// RDF Term interpretation.
16pub trait TermInterpretation<I, B, L = Literal>:
17	IdInterpretation<I, B> + LiteralInterpretation<L>
18{
19	/// Returns the interpretation of the given term, if any.
20	fn term_interpretation(&self, term: &Term<Id<I, B>, L>) -> Option<Self::Resource> {
21		match term {
22			Term::Id(id) => self.id_interpretation(id),
23			Term::Literal(l) => self.literal_interpretation(l),
24		}
25	}
26
27	fn lexical_term_interpretation(
28		&self,
29		vocabulary: &impl Vocabulary<Iri = I, BlankId = B, Literal = L>,
30		term: Term<Id<&Iri, &BlankId>, LiteralRef<I>>,
31	) -> Option<Self::Resource> {
32		match term {
33			Term::Id(id) => self.lexical_id_interpretation(vocabulary, id),
34			Term::Literal(l) => self.lexical_literal_interpretation(vocabulary, l),
35		}
36	}
37}
38
39impl<I, B, L, T: IdInterpretation<I, B> + LiteralInterpretation<L>> TermInterpretation<I, B, L>
40	for T
41{
42}
43
44pub trait TermInterpretationMut<I, B, L = Literal>:
45	IdInterpretationMut<I, B> + LiteralInterpretationMut<L>
46{
47	fn interpret_term(&mut self, term: Term<Id<I, B>, L>) -> Self::Resource {
48		match term {
49			Term::Id(id) => self.interpret_id(id),
50			Term::Literal(l) => self.interpret_literal(l),
51		}
52	}
53
54	fn interpret_lexical_term(
55		&mut self,
56		vocabulary: &mut impl VocabularyMut<Iri = I, BlankId = B, Literal = L>,
57		term: Term<Id<&Iri, &BlankId>, LiteralRef<I>>,
58	) -> Self::Resource {
59		match term {
60			Term::Id(id) => self.interpret_lexical_id(vocabulary, id),
61			Term::Literal(l) => self.interpret_lexical_literal(vocabulary, l),
62		}
63	}
64
65	fn interpret_owned_lexical_term(
66		&mut self,
67		vocabulary: &mut impl VocabularyMut<Iri = I, BlankId = B, Literal = L>,
68		term: Term<Id, Literal<I>>,
69	) -> Self::Resource {
70		match term {
71			Term::Id(id) => self.interpret_owned_lexical_id(vocabulary, id),
72			Term::Literal(l) => self.interpret_owned_lexical_literal(vocabulary, l),
73		}
74	}
75
76	fn interpret_full_lexical_term(
77		&mut self,
78		vocabulary: &mut impl VocabularyMut<Iri = I, BlankId = B, Literal = L>,
79		term: Term,
80	) -> Self::Resource {
81		match term {
82			Term::Id(id) => self.interpret_owned_lexical_id(vocabulary, id),
83			Term::Literal(l) => self.interpret_full_lexical_literal(vocabulary, l),
84		}
85	}
86}
87
88impl<I, B, L, T: IdInterpretationMut<I, B> + LiteralInterpretationMut<L>>
89	TermInterpretationMut<I, B, L> for T
90{
91}
92
93pub type TermOf<'a, I> = Term<
94	Id<&'a <I as ReverseIriInterpretation>::Iri, &'a <I as ReverseBlankIdInterpretation>::BlankId>,
95	&'a <I as ReverseLiteralInterpretation>::Literal,
96>;
97
98pub trait ReverseTermInterpretation:
99	ReverseIdInterpretation + ReverseLiteralInterpretation
100{
101	fn terms_of<'a>(&'a self, id: &'a Self::Resource) -> TermsOf<'a, Self> {
102		TermsOf {
103			ids: self.ids_of(id),
104			literals: self.literals_of(id),
105		}
106	}
107
108	fn term_of<'a>(&'a self, id: &'a Self::Resource) -> Option<TermOf<'a, Self>> {
109		self.terms_of(id).next()
110	}
111
112	fn has_term(&self, id: &Self::Resource) -> bool {
113		self.term_of(id).is_some()
114	}
115
116	fn quads_of<'a>(
117		&'a self,
118		quad: Quad<&'a Self::Resource, &'a Self::Resource, &'a Self::Resource, &'a Self::Resource>,
119	) -> QuadsOf<'a, Self> {
120		QuadsOf {
121			s: self.ids_of(quad.0),
122			p: self.iris_of(quad.1),
123			o: self.terms_of(quad.2),
124			g: quad.3.map(|g| self.ids_of(g)),
125			pogs: None,
126		}
127	}
128
129	fn grdf_quads_of<'a>(
130		&'a self,
131		quad: Quad<&'a Self::Resource, &'a Self::Resource, &'a Self::Resource, &'a Self::Resource>,
132	) -> GrdfQuadsOf<'a, Self> {
133		GrdfQuadsOf {
134			s: self.terms_of(quad.0),
135			p: self.terms_of(quad.1),
136			o: self.terms_of(quad.2),
137			g: quad.3.map(|g| self.terms_of(g)),
138			pogs: None,
139		}
140	}
141}
142
143pub struct QuadsOf<'a, I: ?Sized + ReverseTermInterpretation> {
144	s: IdsOf<'a, I>,
145	p: I::Iris<'a>,
146	o: TermsOf<'a, I>,
147	g: Option<IdsOf<'a, I>>,
148	pogs: Option<PogsOf<'a, I>>,
149}
150
151impl<'a, I: ?Sized + ReverseTermInterpretation> Iterator for QuadsOf<'a, I> {
152	type Item = Quad<
153		Id<&'a I::Iri, &'a I::BlankId>,
154		&'a I::Iri,
155		Term<Id<&'a I::Iri, &'a I::BlankId>, &'a I::Literal>,
156		Id<&'a I::Iri, &'a I::BlankId>,
157	>;
158
159	fn next(&mut self) -> Option<Self::Item> {
160		loop {
161			match self.pogs.as_mut() {
162				Some(pogs) => match pogs.next() {
163					Some(quad) => break Some(quad),
164					None => self.pogs = None,
165				},
166				None => match self.s.next() {
167					Some(s) => {
168						self.pogs = Some(PogsOf {
169							s,
170							p: self.p.clone(),
171							o: self.o.clone(),
172							g: self.g.clone(),
173							ogs: None,
174						})
175					}
176					None => break None,
177				},
178			}
179		}
180	}
181}
182
183struct PogsOf<'a, I: ?Sized + ReverseTermInterpretation> {
184	s: Id<&'a I::Iri, &'a I::BlankId>,
185	p: I::Iris<'a>,
186	o: TermsOf<'a, I>,
187	g: Option<IdsOf<'a, I>>,
188	ogs: Option<OgsOf<'a, I>>,
189}
190
191impl<'a, I: ?Sized + ReverseTermInterpretation> Iterator for PogsOf<'a, I> {
192	type Item = Quad<
193		Id<&'a I::Iri, &'a I::BlankId>,
194		&'a I::Iri,
195		Term<Id<&'a I::Iri, &'a I::BlankId>, &'a I::Literal>,
196		Id<&'a I::Iri, &'a I::BlankId>,
197	>;
198
199	fn next(&mut self) -> Option<Self::Item> {
200		loop {
201			match self.ogs.as_mut() {
202				Some(ogs) => match ogs.next() {
203					Some(quad) => break Some(quad),
204					None => self.ogs = None,
205				},
206				None => match self.p.next() {
207					Some(p) => {
208						self.ogs = Some(OgsOf {
209							s: self.s,
210							p,
211							o: self.o.clone(),
212							g: self.g.clone(),
213							gs: None,
214						})
215					}
216					None => break None,
217				},
218			}
219		}
220	}
221}
222
223struct OgsOf<'a, I: ?Sized + ReverseTermInterpretation> {
224	s: Id<&'a I::Iri, &'a I::BlankId>,
225	p: &'a I::Iri,
226	o: TermsOf<'a, I>,
227	g: Option<IdsOf<'a, I>>,
228	gs: Option<GsOf<'a, I>>,
229}
230
231impl<'a, I: ?Sized + ReverseTermInterpretation> Iterator for OgsOf<'a, I> {
232	type Item = Quad<
233		Id<&'a I::Iri, &'a I::BlankId>,
234		&'a I::Iri,
235		Term<Id<&'a I::Iri, &'a I::BlankId>, &'a I::Literal>,
236		Id<&'a I::Iri, &'a I::BlankId>,
237	>;
238
239	fn next(&mut self) -> Option<Self::Item> {
240		loop {
241			match self.gs.as_mut() {
242				Some(gs) => match gs.next() {
243					Some(quad) => break Some(quad),
244					None => self.gs = None,
245				},
246				None => match self.o.next() {
247					Some(o) => match self.g.clone() {
248						Some(g) => {
249							self.gs = Some(GsOf {
250								s: self.s,
251								p: self.p,
252								o,
253								g,
254							})
255						}
256						None => break Some(Quad(self.s, self.p, o, None)),
257					},
258					None => break None,
259				},
260			}
261		}
262	}
263}
264
265struct GsOf<'a, I: ?Sized + ReverseTermInterpretation> {
266	s: Id<&'a I::Iri, &'a I::BlankId>,
267	p: &'a I::Iri,
268	o: Term<Id<&'a I::Iri, &'a I::BlankId>, &'a I::Literal>,
269	g: IdsOf<'a, I>,
270}
271
272impl<'a, I: ?Sized + ReverseTermInterpretation> Iterator for GsOf<'a, I> {
273	type Item = Quad<
274		Id<&'a I::Iri, &'a I::BlankId>,
275		&'a I::Iri,
276		Term<Id<&'a I::Iri, &'a I::BlankId>, &'a I::Literal>,
277		Id<&'a I::Iri, &'a I::BlankId>,
278	>;
279
280	fn next(&mut self) -> Option<Self::Item> {
281		self.g.next().map(|g| Quad(self.s, self.p, self.o, Some(g)))
282	}
283}
284
285pub struct GrdfQuadsOf<'a, I: ?Sized + ReverseTermInterpretation> {
286	s: TermsOf<'a, I>,
287	p: TermsOf<'a, I>,
288	o: TermsOf<'a, I>,
289	g: Option<TermsOf<'a, I>>,
290	pogs: Option<GrdfPogsOf<'a, I>>,
291}
292
293impl<'a, I: ?Sized + ReverseTermInterpretation> Iterator for GrdfQuadsOf<'a, I> {
294	type Item = UninterpretedGrdfQuadRef<'a, I>;
295
296	fn next(&mut self) -> Option<Self::Item> {
297		loop {
298			match self.pogs.as_mut() {
299				Some(pogs) => match pogs.next() {
300					Some(quad) => break Some(quad),
301					None => self.pogs = None,
302				},
303				None => match self.s.next() {
304					Some(s) => {
305						self.pogs = Some(GrdfPogsOf {
306							s,
307							p: self.p.clone(),
308							o: self.o.clone(),
309							g: self.g.clone(),
310							ogs: None,
311						})
312					}
313					None => break None,
314				},
315			}
316		}
317	}
318}
319
320struct GrdfPogsOf<'a, I: ?Sized + ReverseTermInterpretation> {
321	s: UninterpretedTermRef<'a, I>,
322	p: TermsOf<'a, I>,
323	o: TermsOf<'a, I>,
324	g: Option<TermsOf<'a, I>>,
325	ogs: Option<GrdfOgsOf<'a, I>>,
326}
327
328impl<'a, I: ?Sized + ReverseTermInterpretation> Iterator for GrdfPogsOf<'a, I> {
329	type Item = UninterpretedGrdfQuadRef<'a, I>;
330
331	fn next(&mut self) -> Option<Self::Item> {
332		loop {
333			match self.ogs.as_mut() {
334				Some(ogs) => match ogs.next() {
335					Some(quad) => break Some(quad),
336					None => self.ogs = None,
337				},
338				None => match self.p.next() {
339					Some(p) => {
340						self.ogs = Some(GrdfOgsOf {
341							s: self.s,
342							p,
343							o: self.o.clone(),
344							g: self.g.clone(),
345							gs: None,
346						})
347					}
348					None => break None,
349				},
350			}
351		}
352	}
353}
354
355struct GrdfOgsOf<'a, I: ?Sized + ReverseTermInterpretation> {
356	s: UninterpretedTermRef<'a, I>,
357	p: UninterpretedTermRef<'a, I>,
358	o: TermsOf<'a, I>,
359	g: Option<TermsOf<'a, I>>,
360	gs: Option<GrdfGsOf<'a, I>>,
361}
362
363impl<'a, I: ?Sized + ReverseTermInterpretation> Iterator for GrdfOgsOf<'a, I> {
364	type Item = UninterpretedGrdfQuadRef<'a, I>;
365
366	fn next(&mut self) -> Option<Self::Item> {
367		loop {
368			match self.gs.as_mut() {
369				Some(gs) => match gs.next() {
370					Some(quad) => break Some(quad),
371					None => self.gs = None,
372				},
373				None => match self.o.next() {
374					Some(o) => match self.g.clone() {
375						Some(g) => {
376							self.gs = Some(GrdfGsOf {
377								s: self.s,
378								p: self.p,
379								o,
380								g,
381							})
382						}
383						None => break Some(Quad(self.s, self.p, o, None)),
384					},
385					None => break None,
386				},
387			}
388		}
389	}
390}
391
392struct GrdfGsOf<'a, I: ?Sized + ReverseTermInterpretation> {
393	s: UninterpretedTermRef<'a, I>,
394	p: UninterpretedTermRef<'a, I>,
395	o: UninterpretedTermRef<'a, I>,
396	g: TermsOf<'a, I>,
397}
398
399impl<'a, I: ?Sized + ReverseTermInterpretation> Iterator for GrdfGsOf<'a, I> {
400	type Item = UninterpretedGrdfQuadRef<'a, I>;
401
402	fn next(&mut self) -> Option<Self::Item> {
403		self.g.next().map(|g| Quad(self.s, self.p, self.o, Some(g)))
404	}
405}
406
407impl<I: ?Sized + ReverseIdInterpretation + ReverseLiteralInterpretation> ReverseTermInterpretation
408	for I
409{
410}
411
412pub trait ReverseLiteralInterpretationMut: ReverseLiteralInterpretation {
413	/// Assigns the given literal to the given resource.
414	fn assign_literal(&mut self, resource: &Self::Resource, literal: Self::Literal) -> bool;
415}
416
417/// Mutable reverse term identifier interpretation.
418///
419/// Used to associate terms to resources.
420pub trait ReverseTermInterpretationMut:
421	ReverseIdInterpretationMut + ReverseLiteralInterpretationMut
422{
423	/// Assigns the given term to the given resource.
424	fn assign_term(
425		&mut self,
426		resource: &Self::Resource,
427		term: Term<Id<Self::Iri, Self::BlankId>, Self::Literal>,
428	) -> bool {
429		match term {
430			Term::Id(id) => self.assign_id(resource, id),
431			Term::Literal(l) => self.assign_literal(resource, l),
432		}
433	}
434
435	/// Assigns a term to all the interpreted resources.
436	fn assign_terms(
437		&mut self,
438		mut f: impl FnMut(
439			&Self,
440			&Self::Resource,
441		) -> Option<Term<Id<Self::Iri, Self::BlankId>, Self::Literal>>,
442	) where
443		Self::Resource: Clone,
444		Self: TraversableInterpretation,
445	{
446		let mut terms = Vec::new();
447		for r in self.resources() {
448			if let Some(term) = f(self, r) {
449				terms.push((r.clone(), term))
450			}
451		}
452
453		for (r, term) in terms {
454			self.assign_term(&r, term);
455		}
456	}
457
458	/// Generates and assign a node identifier for all the resources that don't
459	/// have any term, using the given generator.
460	fn generate_ids<V: IriVocabulary + BlankIdVocabulary>(
461		&mut self,
462		vocabulary: &mut V,
463		generator: &mut impl Generator<V>,
464	) where
465		Self::Resource: Clone,
466		Self: TraversableInterpretation
467			+ ReverseTermInterpretationMut<Iri = V::Iri, BlankId = V::BlankId>,
468	{
469		self.assign_terms(|i, r| (!i.has_term(r)).then(|| Term::Id(generator.next(vocabulary))))
470	}
471}
472
473impl<I: ReverseIdInterpretationMut + ReverseLiteralInterpretationMut> ReverseTermInterpretationMut
474	for I
475{
476}
477
478/// Iterator over the terms of an interpreted resource.
479pub struct TermsOf<'a, I: 'a + ?Sized + ReverseTermInterpretation> {
480	ids: IdsOf<'a, I>,
481	literals: I::Literals<'a>,
482}
483
484impl<'a, I: 'a + ?Sized + ReverseTermInterpretation> Clone for TermsOf<'a, I> {
485	fn clone(&self) -> Self {
486		Self {
487			ids: self.ids.clone(),
488			literals: self.literals.clone(),
489		}
490	}
491}
492
493impl<'a, I: 'a + ?Sized + ReverseTermInterpretation> Copy for TermsOf<'a, I>
494where
495	I::Iris<'a>: Copy,
496	I::BlankIds<'a>: Copy,
497	I::Literals<'a>: Copy,
498{
499}
500
501impl<'a, I: 'a + ?Sized + ReverseTermInterpretation> Iterator for TermsOf<'a, I> {
502	type Item = UninterpretedTermRef<'a, I>;
503
504	fn next(&mut self) -> Option<Self::Item> {
505		self.ids
506			.next()
507			.map(Term::Id)
508			.or_else(|| self.literals.next().map(Term::Literal))
509	}
510}
rdf_types/interpretation/term.rs

rdf_types/interpretation/
term.rs
