shex_ast/ast/
value_set_value.rs

1use crate::LangOrWildcard;
2use crate::{Exclusion, IriExclusion, LanguageExclusion, LiteralExclusion};
3use iri_s::IriSError;
4use prefixmap::{Deref, DerefError, IriRef};
5use rust_decimal::Decimal;
6use serde::ser::SerializeMap;
7use serde::{
8    de::{self, MapAccess, Unexpected, Visitor},
9    Deserialize, Serialize, Serializer,
10};
11
12use srdf::lang::Lang;
13use srdf::literal::Literal;
14use std::{fmt, result, str::FromStr};
15use thiserror::Error;
16
17use super::{
18    iri_ref_or_wildcard::IriRefOrWildcard, string_or_wildcard::StringOrWildcard, ObjectValue,
19};
20
21#[derive(Debug, PartialEq, Clone)]
22pub enum ValueSetValue {
23    IriStem {
24        stem: IriRef,
25    },
26    IriStemRange {
27        stem: IriRefOrWildcard,
28        exclusions: Option<Vec<IriExclusion>>,
29    },
30    LiteralStem {
31        stem: String,
32    },
33    LiteralStemRange {
34        stem: StringOrWildcard,
35        exclusions: Option<Vec<LiteralExclusion>>,
36    },
37    Language {
38        language_tag: Lang,
39    },
40    LanguageStem {
41        stem: Lang,
42    },
43    LanguageStemRange {
44        stem: LangOrWildcard,
45        exclusions: Option<Vec<LanguageExclusion>>,
46    },
47
48    ObjectValue(ObjectValue),
49}
50
51impl ValueSetValue {
52    pub fn iri(iri: IriRef) -> ValueSetValue {
53        ValueSetValue::ObjectValue(ObjectValue::iri_ref(iri))
54    }
55
56    pub fn string_literal(value: &str, lang: Option<Lang>) -> ValueSetValue {
57        let ov = ObjectValue::Literal(Literal::StringLiteral {
58            lexical_form: value.to_string(),
59            lang,
60        });
61        ValueSetValue::ObjectValue(ov)
62    }
63
64    pub fn datatype_literal(value: &str, type_: &IriRef) -> ValueSetValue {
65        let ov = ObjectValue::datatype_literal(value, type_);
66        ValueSetValue::ObjectValue(ov)
67    }
68
69    pub fn object_value(value: ObjectValue) -> ValueSetValue {
70        ValueSetValue::ObjectValue(value)
71    }
72
73    pub fn language(lang: Lang) -> ValueSetValue {
74        ValueSetValue::Language { language_tag: lang }
75    }
76
77    pub fn language_stem(lang: Lang) -> ValueSetValue {
78        ValueSetValue::LanguageStem { stem: lang }
79    }
80
81    pub fn literal_stem(stem: String) -> ValueSetValue {
82        ValueSetValue::LiteralStem { stem }
83    }
84
85    pub fn string_stem_range(str: String, exc: Vec<LiteralExclusion>) -> ValueSetValue {
86        ValueSetValue::LiteralStemRange {
87            stem: StringOrWildcard::String(str),
88            exclusions: Some(exc),
89        }
90    }
91}
92
93impl Deref for ValueSetValue {
94    fn deref(
95        &self,
96        base: &Option<iri_s::IriS>,
97        prefixmap: &Option<prefixmap::PrefixMap>,
98    ) -> Result<Self, DerefError>
99    where
100        Self: Sized,
101    {
102        match self {
103            ValueSetValue::ObjectValue(ov) => {
104                let ov = ov.deref(base, prefixmap)?;
105                Ok(ValueSetValue::ObjectValue(ov))
106            }
107            ValueSetValue::Language { language_tag } => Ok(ValueSetValue::Language {
108                language_tag: language_tag.clone(),
109            }),
110            ValueSetValue::LanguageStem { stem } => {
111                Ok(ValueSetValue::LanguageStem { stem: stem.clone() })
112            }
113            ValueSetValue::IriStem { stem } => Ok(ValueSetValue::IriStem { stem: stem.clone() }),
114            ValueSetValue::IriStemRange { stem, exclusions } => Ok(ValueSetValue::IriStemRange {
115                stem: stem.clone(),
116                exclusions: exclusions.clone(),
117            }),
118            ValueSetValue::LanguageStemRange { stem, exclusions } => {
119                Ok(ValueSetValue::LanguageStemRange {
120                    stem: stem.clone(),
121                    exclusions: exclusions.clone(),
122                })
123            }
124            ValueSetValue::LiteralStem { stem } => {
125                Ok(ValueSetValue::LiteralStem { stem: stem.clone() })
126            }
127            ValueSetValue::LiteralStemRange { stem, exclusions } => {
128                Ok(ValueSetValue::LiteralStemRange {
129                    stem: stem.clone(),
130                    exclusions: exclusions.clone(),
131                })
132            }
133        }
134    }
135}
136
137/*impl SerializeStringOrStruct for ValueSetValue {
138    fn serialize_string_or_struct<S>(&self, serializer: S) -> result::Result<S::Ok, S::Error>
139    where
140        S: Serializer,
141    {
142        match &self {
143            ValueSetValue::ObjectValue(ObjectValue::Iri(ref r)) => r.serialize(serializer),
144            _ => self.serialize(serializer),
145        }
146    }
147}*/
148
149impl FromStr for ValueSetValue {
150    type Err = IriSError;
151
152    fn from_str(s: &str) -> Result<Self, Self::Err> {
153        let iri_ref = IriRef::try_from(s)?;
154        Ok(ValueSetValue::ObjectValue(ObjectValue::iri_ref(iri_ref)))
155    }
156}
157
158// TODO: Technical debt
159// The code for serialize/deserialize value_set_value embeds the code to serialize/deserialize object value
160// I would prefer to reuse the code from object_value here...
161
162#[derive(Debug, PartialEq)]
163enum ValueSetValueType {
164    IriStem,
165    LanguageStem,
166    LiteralStem,
167    IriStemRange,
168    LanguageStemRange,
169    LiteralStemRange,
170    Language,
171    Boolean,
172    Integer,
173    Decimal,
174    Double,
175    Other(IriRef),
176}
177
178const BOOLEAN_STR: &str = "http://www.w3.org/2001/XMLSchema#boolean";
179const INTEGER_STR: &str = "http://www.w3.org/2001/XMLSchema#integer";
180const DOUBLE_STR: &str = "http://www.w3.org/2001/XMLSchema#double";
181const DECIMAL_STR: &str = "http://www.w3.org/2001/XMLSchema#decimal";
182
183impl ValueSetValueType {
184    fn parse(s: &str) -> Result<ValueSetValueType, IriSError> {
185        match s {
186            "IriStem" => Ok(ValueSetValueType::IriStem),
187            "LanguageStem" => Ok(ValueSetValueType::LanguageStem),
188            "LiteralStem" => Ok(ValueSetValueType::LiteralStem),
189            "Language" => Ok(ValueSetValueType::Language),
190            "IriStemRange" => Ok(ValueSetValueType::IriStemRange),
191            "LanguageStemRange" => Ok(ValueSetValueType::LanguageStemRange),
192            "LiteralStemRange" => Ok(ValueSetValueType::LiteralStemRange),
193            BOOLEAN_STR => Ok(ValueSetValueType::Boolean),
194            DECIMAL_STR => Ok(ValueSetValueType::Decimal),
195            DOUBLE_STR => Ok(ValueSetValueType::Double),
196            INTEGER_STR => Ok(ValueSetValueType::Integer),
197            other => {
198                let iri = FromStr::from_str(other)?;
199                Ok(ValueSetValueType::Other(iri))
200            }
201        }
202    }
203}
204
205//const BOOLEAN_STR: &str = "http://www.w3.org/2001/XMLSchema#boolean";
206//const INTEGER_STR: &str = "http://www.w3.org/2001/XMLSchema#integer";
207//const DOUBLE_STR: &str = "http://www.w3.org/2001/XMLSchema#double";
208//const DECIMAL_STR: &str = "http://www.w3.org/2001/XMLSchema#decimal";
209
210impl Serialize for ValueSetValue {
211    fn serialize<S>(&self, serializer: S) -> result::Result<S::Ok, S::Error>
212    where
213        S: Serializer,
214    {
215        match self {
216            ValueSetValue::ObjectValue(v) => v.serialize(serializer),
217            ValueSetValue::Language { language_tag } => {
218                let mut map = serializer.serialize_map(Some(2))?;
219                map.serialize_entry("type", "Language")?;
220                map.serialize_entry("languageTag", &language_tag)?;
221                map.end()
222            }
223            ValueSetValue::IriStem { stem } => {
224                let mut map = serializer.serialize_map(Some(2))?;
225                map.serialize_entry("type", "IriStem")?;
226                map.serialize_entry("stem", stem)?;
227                map.end()
228            }
229            ValueSetValue::IriStemRange { stem, exclusions } => {
230                let mut map = serializer.serialize_map(Some(2))?;
231                map.serialize_entry("type", "IriStemRange")?;
232                map.serialize_entry("stem", stem)?;
233                map.serialize_entry("exclusions", exclusions)?;
234                map.end()
235            }
236            ValueSetValue::LanguageStem { stem } => {
237                let mut map = serializer.serialize_map(Some(2))?;
238                map.serialize_entry("type", "LanguageStem")?;
239                map.serialize_entry("stem", &stem)?;
240                map.end()
241            }
242            ValueSetValue::LanguageStemRange { stem, exclusions } => {
243                let mut map = serializer.serialize_map(Some(2))?;
244                map.serialize_entry("type", "LanguageStemRange")?;
245                map.serialize_entry("stem", stem)?;
246                map.serialize_entry("exclusions", exclusions)?;
247                map.end()
248            }
249            ValueSetValue::LiteralStem { stem } => {
250                let mut map = serializer.serialize_map(Some(2))?;
251                map.serialize_entry("type", "LiteralStem")?;
252                map.serialize_entry("stem", stem)?;
253                map.end()
254            }
255            ValueSetValue::LiteralStemRange { stem, exclusions } => {
256                let mut map = serializer.serialize_map(Some(2))?;
257                map.serialize_entry("type", "LiteralStemRange")?;
258                map.serialize_entry("stem", stem)?;
259                map.serialize_entry("exclusions", exclusions)?;
260                map.end()
261            }
262        }
263    }
264}
265
266#[derive(Serialize, Debug, Clone)]
267enum Stem {
268    Str(String),
269    Wildcard,
270}
271
272#[derive(Debug, Error)]
273enum StemError {
274    //#[error("Stem is no string or wildcard: {stem:?}")]
275    //NoStringOrWildCard { stem: Stem },
276    #[error("Stem is no IriRef or wildcard. Stem: {stem:?}, IriError: {err}")]
277    NoIriRefOrWildCard { stem: Stem, err: IriSError },
278
279    //#[error("Stem is no lang or wildcard: {stem:?}")]
280    //NoLangOrWildcard { stem: Stem },
281    #[error("Stem should be IriRef but is wildcard")]
282    StemAsIriRefIsWildcard,
283
284    #[error("Error obtaining IRI for stem: {stem:?} Error: {err}")]
285    IriError { stem: Stem, err: IriSError },
286
287    #[error("Stem is no language: {stem:?}")]
288    NoLanguage { stem: Stem },
289
290    #[error("Stem can not act as string: {stem:?}")]
291    NoString { stem: Stem },
292
293    #[error("Stem can not act as lang: {str}")]
294    NoLang { str: String },
295}
296
297impl Stem {
298    fn as_iri(&self) -> Result<IriRef, StemError> {
299        match self {
300            Stem::Str(s) => {
301                let iri_ref = IriRef::from_str(s.as_str()).map_err(|e| StemError::IriError {
302                    stem: self.clone(),
303                    err: e,
304                })?;
305                Ok(iri_ref)
306            }
307            _ => Err(StemError::StemAsIriRefIsWildcard),
308        }
309    }
310
311    fn as_language(&self) -> Result<String, StemError> {
312        match self {
313            Stem::Str(s) => Ok(s.clone()),
314            _ => Err(StemError::NoLanguage { stem: self.clone() }),
315        }
316    }
317
318    fn as_string(&self) -> Result<String, StemError> {
319        match self {
320            Stem::Str(s) => Ok(s.clone()),
321            _ => Err(StemError::NoString { stem: self.clone() }),
322        }
323    }
324
325    fn as_string_or_wildcard(&self) -> Result<StringOrWildcard, StemError> {
326        match self {
327            Stem::Str(s) => Ok(StringOrWildcard::String(s.clone())),
328            Stem::Wildcard => Ok(StringOrWildcard::Wildcard),
329        }
330    }
331
332    fn as_iri_or_wildcard(&self) -> Result<IriRefOrWildcard, StemError> {
333        match self {
334            Stem::Str(s) => {
335                let iri = FromStr::from_str(s).map_err(|err| StemError::NoIriRefOrWildCard {
336                    stem: self.clone(),
337                    err,
338                })?;
339                Ok(IriRefOrWildcard::IriRef(IriRef::iri(iri)))
340            }
341            Stem::Wildcard => Ok(IriRefOrWildcard::Wildcard),
342        }
343    }
344
345    fn as_lang_or_wildcard(&self) -> Result<LangOrWildcard, StemError> {
346        match self {
347            Stem::Str(s) => {
348                let lang =
349                    FromStr::from_str(s).map_err(|_| StemError::NoLang { str: s.clone() })?;
350                Ok(lang)
351            }
352            Stem::Wildcard => Ok(LangOrWildcard::Wildcard),
353        }
354    }
355}
356
357impl<'de> Deserialize<'de> for Stem {
358    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
359    where
360        D: serde::Deserializer<'de>,
361    {
362        enum Field {
363            Type,
364        }
365
366        impl<'de> Deserialize<'de> for Field {
367            fn deserialize<D>(deserializer: D) -> Result<Field, D::Error>
368            where
369                D: serde::Deserializer<'de>,
370            {
371                struct FieldVisitor;
372
373                impl Visitor<'_> for FieldVisitor {
374                    type Value = Field;
375
376                    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
377                        formatter.write_str("stem value or wildcard with `type`")
378                    }
379
380                    fn visit_str<E>(self, value: &str) -> Result<Field, E>
381                    where
382                        E: de::Error,
383                    {
384                        match value {
385                            "type" => Ok(Field::Type),
386                            _ => Err(de::Error::unknown_field(value, FIELDS)),
387                        }
388                    }
389                }
390
391                deserializer.deserialize_identifier(FieldVisitor)
392            }
393        }
394
395        struct StemVisitor;
396
397        const FIELDS: &[&str] = &["type"];
398
399        impl<'de> Visitor<'de> for StemVisitor {
400            type Value = Stem;
401
402            fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
403                formatter.write_str("stem value")
404            }
405
406            fn visit_str<E>(self, s: &str) -> Result<Self::Value, E>
407            where
408                E: de::Error,
409            {
410                Ok(Stem::Str(s.to_string()))
411            }
412
413            fn visit_map<V>(self, mut map: V) -> Result<Stem, V::Error>
414            where
415                V: MapAccess<'de>,
416            {
417                let mut type_: Option<StemType> = None;
418                while let Some(key) = map.next_key()? {
419                    match key {
420                        Field::Type => {
421                            if type_.is_some() {
422                                return Err(de::Error::duplicate_field("type"));
423                            }
424                            let value: String = map.next_value()?;
425
426                            let parsed_type_ = StemType::parse(value.as_str()).map_err(|e| {
427                                de::Error::custom(format!(
428                                    "Error parsing stem type, found: {value}. Error: {e:?}"
429                                ))
430                            })?;
431                            type_ = Some(parsed_type_);
432                        }
433                    }
434                }
435                match type_ {
436                    Some(StemType::Wildcard) => Ok(Stem::Wildcard),
437                    _ => Err(de::Error::custom("Unknown stem type")),
438                }
439            }
440        }
441        deserializer.deserialize_any(StemVisitor)
442    }
443}
444
445enum StemType {
446    // Str,
447    Wildcard,
448}
449
450#[derive(Debug)]
451#[allow(dead_code)]
452struct StemTypeError {
453    stem_type: String,
454}
455
456impl StemType {
457    fn parse(s: &str) -> Result<StemType, StemTypeError> {
458        match s {
459            "Wildcard" => Ok(StemType::Wildcard),
460            _ => Err(StemTypeError {
461                stem_type: s.to_string(),
462            }),
463        }
464    }
465}
466
467impl<'de> Deserialize<'de> for ValueSetValue {
468    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
469    where
470        D: serde::Deserializer<'de>,
471    {
472        enum Field {
473            Type,
474            Value,
475            Language,
476            Stem,
477            Exclusions,
478            LanguageTag,
479        }
480
481        impl<'de> Deserialize<'de> for Field {
482            fn deserialize<D>(deserializer: D) -> Result<Field, D::Error>
483            where
484                D: serde::Deserializer<'de>,
485            {
486                struct FieldVisitor;
487
488                impl Visitor<'_> for FieldVisitor {
489                    type Value = Field;
490
491                    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
492                        formatter.write_str(
493                                "field of value set value: `type` or `value` or `language` or `stem` or `exclusions`",
494                            )
495                    }
496
497                    fn visit_str<E>(self, value: &str) -> Result<Field, E>
498                    where
499                        E: de::Error,
500                    {
501                        match value {
502                            "type" => Ok(Field::Type),
503                            "value" => Ok(Field::Value),
504                            "stem" => Ok(Field::Stem),
505                            "language" => Ok(Field::Language),
506                            "languageTag" => Ok(Field::LanguageTag),
507                            "exclusions" => Ok(Field::Exclusions),
508                            _ => Err(de::Error::unknown_field(value, FIELDS)),
509                        }
510                    }
511                }
512
513                deserializer.deserialize_identifier(FieldVisitor)
514            }
515        }
516
517        struct ValueSetValueVisitor;
518
519        const FIELDS: &[&str] = &[
520            "type",
521            "value",
522            "stem",
523            "language",
524            "languageTag",
525            "exclusions",
526        ];
527
528        impl<'de> Visitor<'de> for ValueSetValueVisitor {
529            type Value = ValueSetValue;
530
531            fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
532                formatter.write_str("ValueSet value")
533            }
534
535            fn visit_str<E>(self, s: &str) -> Result<Self::Value, E>
536            where
537                E: de::Error,
538            {
539                FromStr::from_str(s)
540                    .map_err(|e| de::Error::custom(format!("Error parsing string `{s}`: {e}")))
541            }
542
543            fn visit_map<V>(self, mut map: V) -> Result<ValueSetValue, V::Error>
544            where
545                V: MapAccess<'de>,
546            {
547                let mut type_: Option<ValueSetValueType> = None;
548                let mut stem: Option<Stem> = None;
549                let mut value: Option<String> = None;
550                let mut language_tag: Option<String> = None;
551                let mut language: Option<String> = None;
552                let mut exclusions: Option<Vec<Exclusion>> = None;
553                while let Some(key) = map.next_key()? {
554                    match key {
555                        Field::Type => {
556                            if type_.is_some() {
557                                return Err(de::Error::duplicate_field("type"));
558                            }
559                            let value: String = map.next_value()?;
560
561                            let parsed_type_ =
562                                ValueSetValueType::parse(value.as_str()).map_err(|e| {
563                                    de::Error::custom(format!(
564                                    "Error parsing ValueSetValue type, found: {value}. Error: {e}"
565                                ))
566                                })?;
567                            type_ = Some(parsed_type_);
568                        }
569                        Field::Value => {
570                            if value.is_some() {
571                                return Err(de::Error::duplicate_field("value"));
572                            }
573                            value = Some(map.next_value()?);
574                        }
575                        Field::Language => {
576                            if language.is_some() {
577                                return Err(de::Error::duplicate_field("language"));
578                            }
579                            language = Some(map.next_value()?);
580                        }
581                        Field::Stem => {
582                            if stem.is_some() {
583                                return Err(de::Error::duplicate_field("stem"));
584                            }
585                            stem = Some(map.next_value()?);
586                        }
587                        Field::Exclusions => {
588                            if exclusions.is_some() {
589                                return Err(de::Error::duplicate_field("exclusions"));
590                            }
591                            exclusions = Some(map.next_value()?);
592                        }
593                        Field::LanguageTag => {
594                            if language_tag.is_some() {
595                                return Err(de::Error::duplicate_field("languageTag"));
596                            }
597                            language_tag = Some(map.next_value()?);
598                        }
599                    }
600                }
601                match type_ {
602                    Some(ValueSetValueType::LiteralStemRange) => match stem {
603                        Some(stem) => match exclusions {
604                            Some(excs) => {
605                                let lit_excs = Exclusion::parse_literal_exclusions(excs).map_err(|e| {
606                                    de::Error::custom(format!("LiteralStemRange: some exclusions are not literal exclusions: {e:?}"))
607                                })?;
608                                let stem = stem.as_string_or_wildcard().map_err(|e| {
609                                    de::Error::custom(format!("LiteralStemRange: stem is not string or wildcard. stem `{stem:?}`: {e:?}"))
610                                })?;
611                                Ok(ValueSetValue::LiteralStemRange {
612                                    stem,
613                                    exclusions: Some(lit_excs),
614                                })
615                            }
616                            None => {
617                                todo!()
618                            }
619                        },
620                        None => Err(de::Error::missing_field("stem")),
621                    },
622                    Some(ValueSetValueType::LanguageStemRange) => match stem {
623                        Some(stem) => match exclusions {
624                            Some(excs) => {
625                                let lang_excs = Exclusion::parse_language_exclusions(excs).map_err(|e| {
626                                    de::Error::custom(format!("LanguageStemRange: some exclusions are not Lang exclusions: {e:?}"))
627                                })?;
628                                let stem = stem.as_lang_or_wildcard().map_err(|e| {
629                                    de::Error::custom(format!("LanguageStemRange: stem is not lang or wildcard. stem `{stem:?}`: {e:?}"))
630                                })?;
631                                Ok(ValueSetValue::LanguageStemRange {
632                                    stem,
633                                    exclusions: Some(lang_excs),
634                                })
635                            }
636                            None => Err(de::Error::missing_field("exclusions")),
637                        },
638                        None => Err(de::Error::missing_field("stem")),
639                    },
640                    Some(ValueSetValueType::IriStemRange) => match stem {
641                        Some(stem) => match exclusions {
642                            Some(excs) => {
643                                let iri_excs = Exclusion::parse_iri_exclusions(excs).map_err(|e| {
644                                    de::Error::custom(format!("IriStemRange: some exclusions are not IRI exclusions: {e:?}"))
645                                })?;
646                                let stem = stem.as_iri_or_wildcard().map_err(|e| {
647                                    de::Error::custom(format!("IriStemRange: stem is not string or wildcard. stem `{stem:?}`: {e:?}"))
648                                })?;
649                                Ok(ValueSetValue::IriStemRange {
650                                    stem,
651                                    exclusions: Some(iri_excs),
652                                })
653                            }
654                            None => Err(de::Error::missing_field("exclusions")),
655                        },
656                        None => Err(de::Error::missing_field("stem")),
657                    },
658                    Some(ValueSetValueType::LiteralStem) => match stem {
659                        Some(stem) => {
660                            let stem = stem.as_string().map_err(|_e| {
661                                de::Error::custom(
662                                    "LiteralStem: value of stem must be a string".to_string(),
663                                )
664                            })?;
665                            Ok(ValueSetValue::LiteralStem { stem })
666                        }
667                        None => Err(de::Error::missing_field("stem")),
668                    },
669                    Some(ValueSetValueType::LanguageStem) => match stem {
670                        Some(stem) => {
671                            let stem = stem.as_language().map_err(|e| {
672                                de::Error::custom(format!(
673                                    "LanguageStem: stem is not a language: {e:?}"
674                                ))
675                            })?;
676                            Ok(ValueSetValue::LanguageStem {
677                                stem: Lang::new_unchecked(stem),
678                            })
679                        }
680                        None => Err(de::Error::missing_field("stem")),
681                    },
682                    Some(ValueSetValueType::Language) => match language_tag {
683                        Some(language_tag) => Ok(ValueSetValue::Language {
684                            language_tag: Lang::new_unchecked(language_tag),
685                        }),
686                        None => Err(de::Error::missing_field("languageTag")),
687                    },
688                    Some(ValueSetValueType::IriStem) => match stem {
689                        Some(stem) => {
690                            let iri_ref = stem.as_iri().map_err(|e| {
691                                de::Error::custom(format!(
692                                    "Can't parse stem `{stem:?}` as IRIREF for IriStem. Error: {e:?}"
693                                ))
694                            })?;
695                            Ok(ValueSetValue::IriStem { stem: iri_ref })
696                        }
697                        None => Err(de::Error::missing_field("stem")),
698                    },
699                    Some(ValueSetValueType::Boolean) => match value {
700                        Some(s) => match s.as_str() {
701                            "false" => Ok(ValueSetValue::ObjectValue(ObjectValue::bool(false))),
702                            "true" => Ok(ValueSetValue::ObjectValue(ObjectValue::bool(true))),
703                            _ => Err(de::Error::invalid_value(Unexpected::Str(&s), &self)),
704                        },
705                        None => Err(de::Error::missing_field("value")),
706                    },
707                    Some(ValueSetValueType::Double) => match value {
708                        Some(s) => {
709                            let n = f64::from_str(&s).map_err(|e| {
710                                de::Error::custom(format!(
711                                    "Can't parse value {s} as double: Error {e}"
712                                ))
713                            })?;
714                            Ok(ValueSetValue::ObjectValue(ObjectValue::double(n)))
715                        }
716                        None => Err(de::Error::missing_field("value")),
717                    },
718                    Some(ValueSetValueType::Decimal) => match value {
719                        Some(s) => {
720                            let n = Decimal::from_str(&s).map_err(|e| {
721                                de::Error::custom(format!(
722                                    "Can't parse value {s} as decimal: Error {e}"
723                                ))
724                            })?;
725                            let v = ValueSetValue::ObjectValue(ObjectValue::decimal(n));
726                            Ok(v)
727                        }
728                        None => Err(de::Error::missing_field("value")),
729                    },
730                    Some(ValueSetValueType::Integer) => match value {
731                        Some(s) => {
732                            let n = isize::from_str(&s).map_err(|e| {
733                                de::Error::custom(format!(
734                                    "Can't parse value {s} as integer: Error {e}"
735                                ))
736                            })?;
737                            let v = ValueSetValue::ObjectValue(ObjectValue::integer(n));
738                            Ok(v)
739                        }
740                        None => Err(de::Error::missing_field("value")),
741                    },
742                    Some(ValueSetValueType::Other(iri)) => match value {
743                        Some(v) => match language_tag {
744                            Some(lang) => Ok(ValueSetValue::ObjectValue(ObjectValue::Literal(
745                                Literal::StringLiteral {
746                                    lexical_form: v,
747                                    lang: Some(Lang::new_unchecked(lang)),
748                                },
749                            ))),
750                            None => Ok(ValueSetValue::datatype_literal(&v, &iri)),
751                        },
752                        None => Err(de::Error::missing_field("value")),
753                    },
754                    None => match value {
755                        Some(lexical_form) => match language {
756                            Some(language) => Ok(ValueSetValue::ObjectValue(ObjectValue::Literal(
757                                Literal::StringLiteral {
758                                    lexical_form,
759                                    lang: Some(Lang::new_unchecked(language)),
760                                },
761                            ))),
762                            None => Ok(ValueSetValue::ObjectValue(ObjectValue::Literal(
763                                Literal::StringLiteral {
764                                    lexical_form,
765                                    lang: None,
766                                },
767                            ))),
768                        },
769                        None => Err(de::Error::missing_field("value")),
770                    },
771                }
772            }
773        }
774        deserializer.deserialize_any(ValueSetValueVisitor)
775    }
776}
shex_ast/ast/value_set_value.rs

shex_ast/ast/
value_set_value.rs
