sdml_core/model/definitions/
properties.rs

1use crate::{
2    load::ModuleLoader,
3    model::{
4        annotations::AnnotationBuilder,
5        check::{MaybeIncomplete, Validate},
6        identifiers::{Identifier, IdentifierReference},
7        members::MemberDef,
8        modules::Module,
9        values::Value,
10        HasName, HasSourceSpan, References, Span,
11    },
12    store::ModuleStore,
13};
14use std::{collections::BTreeSet, fmt::Debug};
15
16#[cfg(feature = "serde")]
17use serde::{Deserialize, Serialize};
18
19// ------------------------------------------------------------------------------------------------
20// Public Types ❱ Definitions ❱ Properties
21// ------------------------------------------------------------------------------------------------
22
23/// Corresponds to the grammar rule `property_def`.
24#[derive(Clone, Debug)]
25#[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
26pub struct PropertyDef {
27    #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
28    span: Option<Span>,
29    member: MemberDef,
30}
31
32// ------------------------------------------------------------------------------------------------
33// Implementations ❱ Definitions ❱ PropertyDef
34// ------------------------------------------------------------------------------------------------
35
36impl From<&MemberDef> for PropertyDef {
37    fn from(member: &MemberDef) -> Self {
38        Self::new(member.clone())
39    }
40}
41
42impl From<MemberDef> for PropertyDef {
43    fn from(member: MemberDef) -> Self {
44        Self::new(member)
45    }
46}
47
48impl HasSourceSpan for PropertyDef {
49    fn with_source_span(self, span: Span) -> Self {
50        let mut self_mut = self;
51        self_mut.span = Some(span);
52        self_mut
53    }
54
55    fn source_span(&self) -> Option<&Span> {
56        self.span.as_ref()
57    }
58
59    fn set_source_span(&mut self, span: Span) {
60        self.span = Some(span);
61    }
62
63    fn unset_source_span(&mut self) {
64        self.span = None;
65    }
66}
67
68impl References for PropertyDef {
69    fn referenced_annotations<'a>(&'a self, names: &mut BTreeSet<&'a IdentifierReference>) {
70        self.member.referenced_annotations(names);
71    }
72
73    fn referenced_types<'a>(&'a self, names: &mut BTreeSet<&'a IdentifierReference>) {
74        self.member.referenced_types(names);
75    }
76}
77
78impl MaybeIncomplete for PropertyDef {
79    fn is_incomplete(&self, top: &Module, cache: &impl ModuleStore) -> bool {
80        self.member.is_incomplete(top, cache)
81    }
82}
83
84impl AnnotationBuilder for PropertyDef {
85    fn with_predicate<I, V>(self, predicate: I, value: V) -> Self
86    where
87        Self: Sized,
88        I: Into<IdentifierReference>,
89        V: Into<Value>,
90    {
91        let mut self_mut = self;
92        self_mut.member = self_mut.member.with_predicate(predicate, value);
93        self_mut
94    }
95}
96
97impl HasName for PropertyDef {
98    fn name(&self) -> &Identifier {
99        self.member.name()
100    }
101
102    fn set_name(&mut self, name: Identifier) {
103        self.member.set_name(name);
104    }
105}
106
107impl Validate for PropertyDef {
108    fn validate(
109        &self,
110        top: &Module,
111        cache: &impl ModuleStore,
112        loader: &impl ModuleLoader,
113        check_constraints: bool,
114    ) {
115        self.member.validate(top, cache, loader, check_constraints)
116    }
117}
118
119impl PropertyDef {
120    // --------------------------------------------------------------------------------------------
121    // Constructor
122    // --------------------------------------------------------------------------------------------
123
124    pub fn new(member: MemberDef) -> Self {
125        Self { span: None, member }
126    }
127
128    pub fn with_member_def(self, member: MemberDef) -> Self {
129        let mut self_mut = self;
130        self_mut.member = member;
131        self_mut
132    }
133
134    // --------------------------------------------------------------------------------------------
135    // Fields
136    // --------------------------------------------------------------------------------------------
137
138    pub const fn member_def(&self) -> &MemberDef {
139        &self.member
140    }
141
142    pub fn set_member_def(&mut self, member: MemberDef) {
143        self.member = member;
144    }
145}