mavspec_rust_derive 0.6.7

Procedural macros for MAVSpec's Rust code generation toolchain.
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
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138

use quote::quote;

use crate::consts::{ATTR_CRC_EXTRA, ATTR_MESSAGE_ID, MESSAGE_ID_MAX};
use crate::errors::{CrcExtraError, Error, MessageIdError};

pub(crate) struct MessageId {
    literal: syn::LitInt,
    value: u32,
}

pub(crate) struct CrcExtra(syn::LitInt);

impl TryFrom<&Vec<syn::Attribute>> for MessageId {
    type Error = Error;

    fn try_from(value: &Vec<syn::Attribute>) -> Result<Self, Self::Error> {
        Self::try_from_attrs(value)
    }
}

impl TryFrom<&Vec<syn::Attribute>> for CrcExtra {
    type Error = Error;

    fn try_from(value: &Vec<syn::Attribute>) -> Result<Self, Self::Error> {
        Self::try_from_attrs(value)
    }
}

impl From<u8> for CrcExtra {
    fn from(value: u8) -> Self {
        Self(syn::LitInt::new(
            value.to_string().as_str(),
            proc_macro2::Span::call_site(),
        ))
    }
}

impl MessageId {
    pub(crate) fn try_from_attrs(attrs: &Vec<syn::Attribute>) -> Result<Self, Error> {
        let mut message_id: Option<MessageId> = None;

        for attr in attrs {
            if let Some(attr_ident) = attr.path().get_ident() {
                if attr_ident == ATTR_MESSAGE_ID {
                    match attr.parse_args().unwrap() {
                        syn::Expr::Lit(literal) => match literal.lit {
                            syn::Lit::Int(int_literal) => {
                                let value = match int_literal.base10_parse::<u32>() {
                                    Ok(value) => {
                                        if value > MESSAGE_ID_MAX {
                                            return Err(MessageIdError::OutOfBounds(value).into());
                                        }
                                        value
                                    }
                                    Err(err) => {
                                        return Err(MessageIdError::InvalidU32Literal(err).into())
                                    }
                                };

                                message_id = Some(MessageId {
                                    literal: int_literal,
                                    value,
                                });
                            }
                            _ => return Err(MessageIdError::NotAnInteger.into()),
                        },
                        _ => return Err(MessageIdError::NotALiteral.into()),
                    }
                }
            }
        }

        if message_id.is_none() {
            return Err(MessageIdError::MissingAttribute.into());
        }

        Ok(message_id.unwrap())
    }

    pub(crate) fn literal(&self) -> &syn::LitInt {
        &self.literal
    }

    pub(crate) fn supports_mavlink_1(&self) -> bool {
        self.value <= u8::MAX as u32
    }

    pub(crate) fn min_supported_mavlink_version(&self) -> proc_macro2::TokenStream {
        if self.supports_mavlink_1() {
            quote! {mavspec::rust::spec::MavLinkVersion::V1}
        } else {
            quote! {mavspec::rust::spec::MavLinkVersion::V2}
        }
    }
}

impl CrcExtra {
    pub(crate) fn try_from_attrs(attrs: &Vec<syn::Attribute>) -> Result<Self, Error> {
        let mut crc_extra: Option<CrcExtra> = None;

        for attr in attrs {
            if let Some(attr_ident) = attr.path().get_ident() {
                if attr_ident == ATTR_CRC_EXTRA {
                    match attr.parse_args().unwrap() {
                        syn::Expr::Lit(literal) => match literal.lit {
                            syn::Lit::Int(int_literal) => {
                                Self::validate_int_literal(&int_literal)?;

                                crc_extra = Some(CrcExtra(int_literal));
                            }
                            _ => return Err(CrcExtraError::NotAnInteger.into()),
                        },
                        _ => return Err(CrcExtraError::NotALiteral.into()),
                    }
                }
            }
        }

        if crc_extra.is_none() {
            return Err(CrcExtraError::MissingAttribute.into());
        }

        Ok(crc_extra.unwrap())
    }

    pub(crate) fn literal(&self) -> &syn::LitInt {
        &self.0
    }

    fn validate_int_literal(int_literal: &syn::LitInt) -> Result<(), Error> {
        match int_literal.base10_parse::<u8>() {
            Ok(value) => value,
            Err(err) => return Err(CrcExtraError::InvalidU8Literal(err).into()),
        };

        Ok(())
    }
}