rdfx 0.23.0

RDF 1.2 data-structures, traits and utilities: terms (incl. triple terms), triples, quads, interpretations, graphs, datasets, unstar/restar reification helpers.
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

use crate::{Triple, pattern::CanonicalTriplePattern, utils::InfallibleIterator};

use super::{Graph, GraphMut, PatternMatchingGraph, TraversableGraph};

/// Fallible graph.
pub trait FallibleGraph {
    type Subject: crate::IsSubject;
    type Predicate: crate::IsPredicate;
    type Object: crate::IsObject;
    type Error;
}

impl<D: Graph> FallibleGraph for D {
    type Subject = D::Subject;
    type Predicate = D::Predicate;
    type Object = D::Object;
    type Error = std::convert::Infallible;
}

pub trait FallibleTraversableGraph: FallibleGraph {
    type TryTriples<'a>: Iterator<Item = Result<Triple<&'a Self::Subject, &'a Self::Predicate, &'a Self::Object>, Self::Error>>
    where
        Self: 'a;

    fn try_triples(&self) -> Self::TryTriples<'_>;
}

impl<D: TraversableGraph> FallibleTraversableGraph for D {
    type TryTriples<'a>
        = InfallibleIterator<D::Triples<'a>>
    where
        Self: 'a;

    fn try_triples(&self) -> Self::TryTriples<'_> {
        InfallibleIterator(self.triples())
    }
}

/// Pattern-matching-capable fallible graph. Restricted to uniform graphs
/// whose subject type implements [`crate::Resource`] (so refs serve in any
/// position).
pub trait FalliblePatternMatchingGraph: FallibleGraph
where
    <Self as FallibleGraph>::Subject: crate::Resource,
{
    type TryTriplePatternMatching<'a, 'p>: Iterator<Item = Result<Triple<&'a Self::Subject, &'a Self::Subject, &'a Self::Subject>, Self::Error>>
    where
        Self: 'a,
        Self::Subject: 'p;

    fn try_triple_pattern_matching<'p>(&self, pattern: CanonicalTriplePattern<&'p Self::Subject>) -> Self::TryTriplePatternMatching<'_, 'p>;

    fn try_contains_triple(&self, triple: Triple<&Self::Subject, &Self::Subject, &Self::Subject>) -> Result<bool, Self::Error> {
        Ok(self.try_triple_pattern_matching(triple.into()).next().transpose()?.is_some())
    }
}

impl<D: PatternMatchingGraph> FalliblePatternMatchingGraph for D
where
    <D as Graph>::Subject: crate::Resource,
{
    type TryTriplePatternMatching<'a, 'p>
        = InfallibleIterator<D::TriplePatternMatching<'a, 'p>>
    where
        Self: 'a,
        Self::Subject: 'p;

    fn try_triple_pattern_matching<'p>(&self, pattern: CanonicalTriplePattern<&'p Self::Subject>) -> Self::TryTriplePatternMatching<'_, 'p> {
        InfallibleIterator(self.triple_pattern_matching(pattern))
    }
}

/// Fallible mutable graph.
pub trait FallibleGraphMut: FallibleGraph {
    fn try_insert(&mut self, triple: Triple<Self::Subject, Self::Predicate, Self::Object>) -> Result<(), Self::Error>;
}

impl<D: GraphMut> FallibleGraphMut for D {
    fn try_insert(&mut self, triple: Triple<Self::Subject, Self::Predicate, Self::Object>) -> Result<(), Self::Error> {
        self.insert(triple);
        Ok(())
    }
}