shex_ast 0.2.11

RDF data shapes implementation in Rust
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

use rbe::Context;
use serde::Serialize;
use std::fmt::Display;

use crate::{Node, Pred};

/// Context passed to semantic actions when they are executed.
#[derive(Debug, Clone, Hash, PartialEq, Eq, Default, Serialize)]
pub struct SemanticActionContext {
    subject: Option<Node>,
    predicate: Option<Pred>,
    object: Option<Node>,
}

impl SemanticActionContext {
    pub fn s(&self) -> Option<Node> {
        self.subject.clone()
    }

    pub fn p(&self) -> Option<Pred> {
        self.predicate.clone()
    }

    pub fn o(&self) -> Option<Node> {
        self.object.clone()
    }

    pub fn triple(subject: &Node, predicate: &Pred, object: &Node) -> Self {
        SemanticActionContext {
            subject: Some(subject.clone()),
            predicate: Some(predicate.clone()),
            object: Some(object.clone()),
        }
    }

    pub fn subject(subject: &Node) -> Self {
        SemanticActionContext {
            subject: Some(subject.clone()),
            predicate: None,
            object: None,
        }
    }

    pub fn object(object: &Node) -> Self {
        SemanticActionContext {
            subject: None,
            predicate: None,
            object: Some(object.clone()),
        }
    }

    pub fn predicate(predicate: &Pred) -> Self {
        SemanticActionContext {
            subject: None,
            predicate: Some(predicate.clone()),
            object: None,
        }
    }

    pub fn with_subject(mut self, subject: Node) -> Self {
        self.subject = Some(subject);
        self
    }

    pub fn with_predicate(mut self, predicate: Pred) -> Self {
        self.predicate = Some(predicate);
        self
    }

    pub fn with_object(mut self, object: Node) -> Self {
        self.object = Some(object);
        self
    }
}

impl Context for SemanticActionContext {}

impl Display for SemanticActionContext {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(
            f,
            "Context {{ subject: {:?}, predicate: {:?}, object: {:?} }}",
            self.subject, self.predicate, self.object
        )
    }
}