sdml_core/model/definitions/
rdf.rs

1use crate::{
2    load::ModuleLoader,
3    model::{
4        annotations::{AnnotationBuilder, AnnotationOnlyBody, HasAnnotations},
5        check::Validate,
6        identifiers::{Identifier, QualifiedIdentifier},
7        modules::Module,
8        Span,
9    },
10    stdlib,
11    store::ModuleStore,
12};
13use sdml_errors::diagnostics::functions::IdentifierCaseConvention;
14
15#[cfg(feature = "serde")]
16use serde::{Deserialize, Serialize};
17
18// ------------------------------------------------------------------------------------------------
19// Public Types
20// ------------------------------------------------------------------------------------------------
21
22/// Corresponds to the grammar rule `rdf_class_def` and `rdf_property_def`.
23#[derive(Clone, Debug)]
24#[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
25pub struct RdfDef {
26    #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
27    span: Option<Box<Span>>,
28    name: Identifier,
29    body: AnnotationOnlyBody,
30}
31
32// ------------------------------------------------------------------------------------------------
33// Implementations
34// ------------------------------------------------------------------------------------------------
35
36impl_has_name_for!(RdfDef);
37
38impl_has_body_for!(RdfDef, AnnotationOnlyBody);
39
40impl_has_source_span_for!(RdfDef);
41
42impl_references_for!(RdfDef => delegate body);
43
44impl_annotation_builder!(RdfDef);
45
46impl_maybe_incomplete_for!(RdfDef; always false);
47
48impl Validate for RdfDef {
49    fn validate(
50        &self,
51        top: &Module,
52        cache: &impl ModuleStore,
53        loader: &impl ModuleLoader,
54        check_constraints: bool,
55    ) {
56        self.name
57            .validate(top, loader, Some(IdentifierCaseConvention::RdfDefinition));
58        self.body.validate(top, cache, loader, check_constraints);
59    }
60}
61
62impl RdfDef {
63    // --------------------------------------------------------------------------------------------
64    // Constructors
65    // --------------------------------------------------------------------------------------------
66
67    fn new(name: Identifier) -> Self {
68        Self {
69            span: None,
70            name,
71            body: Default::default(),
72        }
73    }
74
75    pub fn class(name: Identifier) -> Self {
76        Self::new(name).with_type(QualifiedIdentifier::new(
77            Identifier::new_unchecked(stdlib::rdfs::MODULE_NAME),
78            Identifier::new_unchecked(stdlib::rdfs::CLASS),
79        ))
80    }
81
82    pub fn is_class(&self) -> bool {
83        self.body.has_rdf_type(
84            &QualifiedIdentifier::new(
85                Identifier::new_unchecked(stdlib::rdfs::MODULE_NAME),
86                Identifier::new_unchecked(stdlib::rdfs::CLASS),
87            )
88            .into(),
89        )
90    }
91
92    pub fn datatype(name: Identifier) -> Self {
93        Self::new(name).with_type(QualifiedIdentifier::new(
94            Identifier::new_unchecked(stdlib::rdfs::MODULE_NAME),
95            Identifier::new_unchecked(stdlib::rdfs::DATATYPE),
96        ))
97    }
98
99    pub fn is_datatype(&self) -> bool {
100        self.body.has_rdf_type(
101            &QualifiedIdentifier::new(
102                Identifier::new_unchecked(stdlib::rdfs::MODULE_NAME),
103                Identifier::new_unchecked(stdlib::rdfs::DATATYPE),
104            )
105            .into(),
106        )
107    }
108
109    pub fn property(name: Identifier) -> Self {
110        Self::new(name).with_type(QualifiedIdentifier::new(
111            Identifier::new_unchecked(stdlib::rdf::MODULE_NAME),
112            Identifier::new_unchecked(stdlib::rdf::PROPERTY),
113        ))
114    }
115
116    pub fn is_property(&self) -> bool {
117        self.body.has_rdf_type(
118            &QualifiedIdentifier::new(
119                Identifier::new_unchecked(stdlib::rdf::MODULE_NAME),
120                Identifier::new_unchecked(stdlib::rdf::PROPERTY),
121            )
122            .into(),
123        )
124    }
125
126    pub fn individual(name: Identifier) -> Self {
127        Self::new(name)
128    }
129}