device-driver-codegen 2.0.0

Internal compiler crate for the device-driver toolkit
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
82

{{self::description_to_docstring(enum_value.description)}}
{{ self::maybe_doc_alias(enum_value.name, Case::Pascal) }}
#[repr({{enum_value.base_type}})]
#[derive(Debug, Copy, Clone, Eq, PartialEq, Hash)]
{% if let Some(defmt_feature) = defmt_feature() %}
#[cfg_attr(feature = "{{defmt_feature}}", derive(defmt::Format))]
{% endif %}
pub enum {{enum_value.name.to_case(Case::Pascal)}} {
    {% for variant in enum_value.variants %}
        {{ self::description_to_docstring(variant.description) }}
        {{ self::maybe_doc_alias(variant.name, Case::Pascal) }}
        {{variant.name.to_case(Case::Pascal)}} {% if variant.catch_all %} ({{enum_value.base_type}}) {% endif %} = {{variant.discriminant}},
    {% endfor %}
}

{% let default_variant = enum_value.default_variant() %}
{% let catch_all_variant = enum_value.catch_all_variant() %}

{% if let Some(default_variant) = default_variant %}
impl Default for {{enum_value.name.to_case(Case::Pascal)}} {
    fn default() -> Self {
        Self::{{default_variant.name.to_case(Case::Pascal)}}
        {% if default_variant.catch_all %}
            ({{default_variant.discriminant}})
        {% endif %}
    }
}
{%endif%}

{% if catch_all_variant.is_some() || default_variant.is_some() %}
impl From<{{enum_value.base_type}}> for {{enum_value.name.to_case(Case::Pascal)}} {
    fn from(val: {{enum_value.base_type}}) -> Self {
        match val {
            {% for variant in enum_value.variants %}
                {% if !(variant.default || variant.catch_all) %}
                    {{variant.discriminant}} => Self::{{variant.name.to_case(Case::Pascal)}},
                {% endif %}
            {% endfor %}
            {% if let Some(catch_all_variant) = catch_all_variant %}
                val => Self::{{catch_all_variant.name.to_case(Case::Pascal)}}(val),
            {% else if let Some(_) = default_variant %}
                _ => Self::default(),
            {% endif %}
        }
    }
}
{% else %}
impl core::convert::TryFrom<{{enum_value.base_type}}> for {{enum_value.name.to_case(Case::Pascal)}} {
    type Error = ::device_driver::ConversionError<{{enum_value.base_type}}>;
    fn try_from(val: {{enum_value.base_type}}) -> Result<Self, Self::Error> {
        match val {
            {% for variant in enum_value.variants %}
                {{variant.discriminant}} => Ok(Self::{{variant.name.to_case(Case::Pascal)}}),
            {% endfor %}
            val => Err(::device_driver::ConversionError { source: val, target: "{{enum_value.name.to_case(Case::Pascal)}}" })
        }
    }
}
{%endif%}

impl From<{{enum_value.name.to_case(Case::Pascal)}}> for {{enum_value.base_type}} {
    fn from(val: {{enum_value.name.to_case(Case::Pascal)}}) -> Self {
        match val {
            {% for variant in enum_value.variants %}
                {% if variant.catch_all %}
                    {{enum_value.name.to_case(Case::Pascal)}}::{{variant.name.to_case(Case::Pascal)}}(num) => num,
                {% else %}
                    {{enum_value.name.to_case(Case::Pascal)}}::{{variant.name.to_case(Case::Pascal)}} => {{variant.discriminant}},
                {% endif %}
            {% endfor %}
        }
    }
}

#[doc(hidden)]
impl ::device_driver::EnumIndex for {{enum_value.name.to_case(Case::Pascal)}} {
    #[track_caller]
    fn index(&self) -> i32 {
        let index = {{enum_value.base_type}}::from(*self);
        index.try_into().unwrap()
    }
}