xsd-parser 1.5.2

Rust code generator for XML schema files
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

use std::collections::HashMap;

use crate::models::{
    meta::{Base, MetaTypeVariant, MetaTypes},
    TypeIdent,
};

#[derive(Debug)]
pub(crate) struct BaseMap(HashMap<TypeIdent, Base>);

impl BaseMap {
    pub(crate) fn new(types: &MetaTypes) -> Self {
        let mut ret = HashMap::new();

        for (ident, type_) in &types.items {
            match &type_.variant {
                MetaTypeVariant::Enumeration(ei) => {
                    if matches!(
                        ei.base.as_ident().and_then(|base| types.get_variant(base)),
                        Some(MetaTypeVariant::Enumeration(_))
                    ) {
                        ret.insert(ident.clone(), ei.base.clone());
                    }
                }
                MetaTypeVariant::Union(ei) => {
                    if matches!(
                        ei.base.as_ident().and_then(|base| types.get_variant(base)),
                        Some(MetaTypeVariant::Union(_))
                    ) {
                        ret.insert(ident.clone(), ei.base.clone());
                    }
                }
                MetaTypeVariant::SimpleType(si) => {
                    ret.insert(ident.clone(), Base::Restriction(si.base.clone()));
                }
                MetaTypeVariant::ComplexType(ci) => {
                    if matches!(
                        ci.base.as_ident().and_then(|base| types.get_variant(base)),
                        Some(MetaTypeVariant::ComplexType(_))
                    ) {
                        ret.insert(ident.clone(), ci.base.clone());
                    }
                }
                _ => (),
            }
        }

        Self(ret)
    }

    pub(crate) fn get_unrestricted<'a>(&'a self, ident: &'a TypeIdent) -> &'a TypeIdent {
        match self.0.get(ident) {
            Some(Base::Restriction(base)) => self.get_unrestricted(base),
            _ => ident,
        }
    }
}