rdf-model 0.3.0

RDF.rs is a Rust framework for working with RDF knowledge graphs.
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

// This is free and unencumbered software released into the public domain.

use crate::{HeapTerm, Quad, QuadPattern, Term, Triple, TriplePattern};

/// An RDF statement.
///
/// See: https://www.w3.org/TR/rdf12-concepts/#dfn-rdf-statement
pub trait Statement {
    type Term: Term + Clone;

    // TODO: associated type defaults (https://github.com/rust-lang/rust/issues/29661)
    //type Term: Term = &dyn Term;

    fn subject(&self) -> &Self::Term;

    fn predicate(&self) -> &Self::Term;

    fn object(&self) -> &Self::Term;

    fn context(&self) -> Option<&Self::Term> {
        None
    }

    fn to_triple(&self) -> Triple<Self::Term> {
        Triple::new(
            self.subject().clone(),
            self.predicate().clone(),
            self.object().clone(),
        )
    }

    fn to_triple_pattern(&self) -> TriplePattern<Self::Term> {
        TriplePattern::new(
            Some(self.subject().clone()),
            Some(self.predicate().clone()),
            Some(self.object().clone()),
        )
    }

    fn to_quad(&self) -> Quad<Self::Term> {
        Quad::new(
            self.subject().clone(),
            self.predicate().clone(),
            self.object().clone(),
            self.context().cloned(),
        )
    }

    fn to_quad_pattern(&self) -> QuadPattern<Self::Term> {
        QuadPattern::new(
            Some(self.subject().clone()),
            Some(self.predicate().clone()),
            Some(self.object().clone()),
            self.context().cloned(),
        )
    }
}

impl core::fmt::Debug for dyn Statement<Term = HeapTerm> {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("Statement")
            .field("subject", &self.subject().value_str())
            .field("predicate", &self.predicate().value_str())
            .field("object", &self.object().value_str())
            .field("context", &self.context().map(|t| t.value_str()))
            .finish()
    }
}