sdml_core/model/constraints/formal/
values.rs

1use crate::model::identifiers::IdentifierReference;
2use crate::model::values::{MappingValue, SimpleValue, ValueConstructor};
3use crate::model::{HasSourceSpan, Span};
4use std::fmt::Display;
5
6#[cfg(feature = "serde")]
7use serde::{Deserialize, Serialize};
8
9// ------------------------------------------------------------------------------------------------
10// Public Types ❱ Constraints ❱ Values
11// ------------------------------------------------------------------------------------------------
12
13#[derive(Clone, Debug)]
14#[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
15pub enum PredicateValue {
16    Simple(SimpleValue),
17    Sequence(SequenceOfPredicateValues),
18}
19
20#[derive(Clone, Debug, Default)]
21#[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
22pub struct SequenceOfPredicateValues {
23    #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
24    span: Option<Span>,
25    values: Vec<PredicateSequenceMember>,
26}
27
28#[derive(Clone, Debug)]
29#[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
30pub enum PredicateSequenceMember {
31    Simple(SimpleValue),
32    ValueConstructor(ValueConstructor),
33    Mapping(MappingValue),
34    Reference(IdentifierReference),
35}
36
37// ------------------------------------------------------------------------------------------------
38// Implementations ❱ Constraints ❱ PredicateValue
39// ------------------------------------------------------------------------------------------------
40
41impl<T> From<T> for PredicateValue
42where
43    T: Into<SimpleValue>,
44{
45    fn from(v: T) -> Self {
46        Self::Simple(v.into())
47    }
48}
49
50impl From<SequenceOfPredicateValues> for PredicateValue {
51    fn from(v: SequenceOfPredicateValues) -> Self {
52        Self::Sequence(v)
53    }
54}
55
56impl PredicateValue {
57    // --------------------------------------------------------------------------------------------
58    // Variants
59    // --------------------------------------------------------------------------------------------
60
61    pub const fn is_simple(&self) -> bool {
62        matches!(self, Self::Simple(_))
63    }
64
65    pub const fn as_simple(&self) -> Option<&SimpleValue> {
66        match self {
67            Self::Simple(v) => Some(v),
68            _ => None,
69        }
70    }
71
72    // --------------------------------------------------------------------------------------------
73
74    pub const fn is_sequence(&self) -> bool {
75        matches!(self, Self::Sequence(_))
76    }
77
78    pub const fn as_sequence(&self) -> Option<&SequenceOfPredicateValues> {
79        match self {
80            Self::Sequence(v) => Some(v),
81            _ => None,
82        }
83    }
84}
85
86// ------------------------------------------------------------------------------------------------
87// Implementations ❱ Constraints ❱ SequenceOfPredicateValues
88// ------------------------------------------------------------------------------------------------
89
90impl From<Vec<PredicateSequenceMember>> for SequenceOfPredicateValues {
91    fn from(values: Vec<PredicateSequenceMember>) -> Self {
92        Self { span: None, values }
93    }
94}
95
96impl FromIterator<PredicateSequenceMember> for SequenceOfPredicateValues {
97    fn from_iter<T: IntoIterator<Item = PredicateSequenceMember>>(iter: T) -> Self {
98        Self::from(Vec::from_iter(iter))
99    }
100}
101
102impl Display for SequenceOfPredicateValues {
103    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
104        write!(
105            f,
106            "[{}]",
107            self.values
108                .iter()
109                .map(|v| v.to_string())
110                .collect::<Vec<String>>()
111                .join(" ")
112        )
113    }
114}
115
116impl HasSourceSpan for SequenceOfPredicateValues {
117    fn with_source_span(self, span: Span) -> Self {
118        let mut self_mut = self;
119        self_mut.span = Some(span);
120        self_mut
121    }
122
123    fn source_span(&self) -> Option<&Span> {
124        self.span.as_ref()
125    }
126
127    fn set_source_span(&mut self, span: Span) {
128        self.span = Some(span);
129    }
130
131    fn unset_source_span(&mut self) {
132        self.span = None;
133    }
134}
135
136impl SequenceOfPredicateValues {
137    pub fn is_empty(&self) -> bool {
138        self.values.is_empty()
139    }
140
141    pub fn len(&self) -> usize {
142        self.values.len()
143    }
144
145    pub fn iter(&self) -> impl Iterator<Item = &PredicateSequenceMember> {
146        self.values.iter()
147    }
148
149    pub fn iter_mut(&mut self) -> impl Iterator<Item = &mut PredicateSequenceMember> {
150        self.values.iter_mut()
151    }
152
153    pub fn push<I>(&mut self, value: I)
154    where
155        I: Into<PredicateSequenceMember>,
156    {
157        self.values.push(value.into())
158    }
159
160    pub fn extend<I>(&mut self, extension: I)
161    where
162        I: IntoIterator<Item = PredicateSequenceMember>,
163    {
164        self.values.extend(extension)
165    }
166}
167
168// ------------------------------------------------------------------------------------------------
169// Implementations ❱ Constraints ❱ PredicateSequenceMember
170// ------------------------------------------------------------------------------------------------
171
172impl<T> From<T> for PredicateSequenceMember
173where
174    T: Into<SimpleValue>,
175{
176    fn from(v: T) -> Self {
177        Self::Simple(v.into())
178    }
179}
180
181impl From<IdentifierReference> for PredicateSequenceMember {
182    fn from(v: IdentifierReference) -> Self {
183        Self::Reference(v)
184    }
185}
186
187impl Display for PredicateSequenceMember {
188    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
189        write!(
190            f,
191            "{}",
192            match self {
193                PredicateSequenceMember::Simple(v) => v.to_string(),
194                PredicateSequenceMember::ValueConstructor(v) => v.to_string(),
195                PredicateSequenceMember::Mapping(v) => v.to_string(),
196                PredicateSequenceMember::Reference(v) => v.to_string(),
197            }
198        )
199    }
200}
201
202impl PredicateSequenceMember {
203    // --------------------------------------------------------------------------------------------
204    // Variants
205    // --------------------------------------------------------------------------------------------
206
207    pub const fn is_simple(&self) -> bool {
208        matches!(self, Self::Simple(_))
209    }
210
211    pub const fn as_simple(&self) -> Option<&SimpleValue> {
212        match self {
213            Self::Simple(v) => Some(v),
214            _ => None,
215        }
216    }
217
218    // --------------------------------------------------------------------------------------------
219
220    pub const fn is_reference(&self) -> bool {
221        matches!(self, Self::Reference(_))
222    }
223
224    pub const fn as_reference(&self) -> Option<&IdentifierReference> {
225        match self {
226            Self::Reference(v) => Some(v),
227            _ => None,
228        }
229    }
230}
sdml_core/model/constraints/formal/values.rs

sdml_core/model/constraints/formal/
values.rs
