cmsis-pack 0.7.2

Rust crate for managing CMSIS Packs
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
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81

use anyhow::Error;
use roxmltree::Node;

use crate::utils::prelude::*;

pub struct ConditionComponent {
    pub device_family: Option<String>,
    pub device_sub_family: Option<String>,
    pub device_variant: Option<String>,
    pub device_vendor: Option<String>,
    pub device_name: Option<String>,
}

impl FromElem for ConditionComponent {
    fn from_elem(e: &Node) -> Result<Self, Error> {
        Ok(ConditionComponent {
            device_family: attr_map(e, "Dfamily").ok(),
            device_sub_family: attr_map(e, "Dsubfamily").ok(),
            device_variant: attr_map(e, "Dvariant").ok(),
            device_vendor: attr_map(e, "Dvendor").ok(),
            device_name: attr_map(e, "Dname").ok(),
        })
    }
}

pub struct Condition {
    pub id: String,
    pub accept: Vec<ConditionComponent>,
    pub deny: Vec<ConditionComponent>,
    pub require: Vec<ConditionComponent>,
}

impl FromElem for Condition {
    fn from_elem(e: &Node) -> Result<Self, Error> {
        assert_root_name(e, "condition")?;
        let mut accept = Vec::new();
        let mut deny = Vec::new();
        let mut require = Vec::new();
        for elem in e.children().filter(|e| e.is_element()) {
            match elem.tag_name().name() {
                "accept" => {
                    accept.push(ConditionComponent::from_elem(e)?);
                }
                "deny" => {
                    deny.push(ConditionComponent::from_elem(e)?);
                }
                "require" => {
                    require.push(ConditionComponent::from_elem(e)?);
                }
                "description" => {}
                _ => {
                    log::warn!(
                        "Found unkonwn element {} in components",
                        elem.tag_name().name()
                    );
                }
            }
        }
        Ok(Condition {
            id: attr_map(e, "id")?,
            accept,
            deny,
            require,
        })
    }
}

#[derive(Default)]
pub struct Conditions(pub Vec<Condition>);

impl FromElem for Conditions {
    fn from_elem(e: &Node) -> Result<Self, Error> {
        assert_root_name(e, "conditions")?;
        Ok(Conditions(
            e.children()
                .filter(|e| e.is_element())
                .flat_map(|c| Condition::from_elem(&c).ok_warn())
                .collect(),
        ))
    }
}