shacl_ast 0.1.76

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

use std::fmt::Display;

use crate::shacl_vocab::{
    sh_target_class, sh_target_node, sh_target_objects_of, sh_target_subjects_of,
};
use prefixmap::IriRef;
use srdf::{rdf_type, BuildRDF, RDFNode};

#[derive(Debug, Clone)]
pub enum Target {
    TargetNode(RDFNode),
    TargetClass(RDFNode),
    TargetSubjectsOf(IriRef),
    TargetObjectsOf(IriRef),
    TargetImplicitClass(RDFNode),
}

impl Target {
    pub fn write<RDF>(&self, rdf_node: &RDFNode, rdf: &mut RDF) -> Result<(), RDF::Err>
    where
        RDF: BuildRDF,
    {
        let node: RDF::Subject = rdf_node.clone().try_into().map_err(|_| unreachable!())?;
        match self {
            Self::TargetNode(target_rdf_node) => {
                rdf.add_triple(node, sh_target_node().clone(), target_rdf_node.clone())
            }
            Self::TargetClass(target_rdf_node) => {
                rdf.add_triple(node, sh_target_class().clone(), target_rdf_node.clone())
            }
            Self::TargetSubjectsOf(iri_ref) => rdf.add_triple(
                node,
                sh_target_subjects_of().clone(),
                iri_ref.get_iri().unwrap().clone(),
            ),
            Self::TargetObjectsOf(iri_ref) => rdf.add_triple(
                node,
                sh_target_objects_of().clone(),
                iri_ref.get_iri().unwrap().clone(),
            ),
            // TODO: check if this is fine
            Self::TargetImplicitClass(target_rdf_node) => {
                rdf.add_triple(node, rdf_type().clone(), target_rdf_node.clone())
            }
        }
    }
}

impl Display for Target {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            Target::TargetNode(node) => write!(f, "targetNode({node})"),
            Target::TargetClass(node) => write!(f, "targetClass({node})"),
            Target::TargetSubjectsOf(node) => write!(f, "targetSubjectsOf({node})"),
            Target::TargetObjectsOf(node) => write!(f, "targetObjectsOf({node})"),
            Target::TargetImplicitClass(node) => write!(f, "targetImplicitClass({node})"),
        }
    }
}