mavinspect 0.1.0-alpha2

MAVInspect is a CLI tool and a library to parse and inspect MAVLink protocol XML definitions
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

use std::collections::HashMap;

#[cfg(feature = "serde")]
use serde::{Deserialize, Serialize};

use crate::proto::mavlink_messages_v1 as proto;
use crate::protocol::{Enum, Message, MessageId};

use super::errors::ProtoImportError;

/// MAVLink dialect specification.
#[derive(Debug, Clone)]
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
pub struct Dialect {
    name: String,
    version: Option<u8>,
    dialect: Option<u8>,
    messages: HashMap<MessageId, Message>,
    enums: HashMap<String, Enum>,
}

impl Dialect {
    /// Default constructor
    ///
    /// # Arguments
    ///
    /// * `name` dialect name
    /// * `version` dialect version
    /// * `version` dialect version (if provided)
    /// * `messages` map of messages
    /// * `enums` map of enums
    pub fn new(
        name: String,
        version: Option<u8>,
        dialect: Option<u8>,
        messages: HashMap<MessageId, Message>,
        enums: HashMap<String, Enum>,
    ) -> Self {
        Self {
            name,
            version,
            dialect,
            messages,
            enums,
        }
    }

    /// Converts to Protobuf [`proto::Dialect`].
    pub fn to_proto(&self) -> proto::Dialect {
        proto::Dialect {
            name: self.name.clone(),
            version: self.version.map(|ver| ver as u32),
            dialect: self.dialect.map(|dialect| dialect as u32),
            messages: self
                .messages
                .iter()
                .map(|(&id, msg)| (id, msg.to_proto()))
                .collect(),
            enums: self
                .enums
                .iter()
                .map(|(name, enm)| (name.clone(), enm.to_proto()))
                .collect(),
        }
    }

    /// Constructs from Protobuf [`proto::Dialect`].
    pub fn from_proto(proto: &proto::Dialect) -> Result<Self, ProtoImportError> {
        let mut messages = HashMap::new();
        let mut enums = HashMap::new();

        for (&id, message) in &proto.messages {
            messages.insert(id, Message::from_proto(message)?);
        }

        for (name, enm) in &proto.enums {
            enums.insert(name.clone(), Enum::from_proto(enm)?);
        }

        Ok(Self {
            name: proto.name.clone(),
            version: proto.version.map(|v| v as u8),
            dialect: proto.dialect.map(|dialect| dialect as u8),
            messages,
            enums,
        })
    }

    /// Dialect name
    pub fn name(&self) -> &String {
        &self.name
    }

    /// Dialect version
    pub fn version(&self) -> Option<u8> {
        self.version
    }

    /// List of messages
    pub fn messages(&self) -> &HashMap<MessageId, Message> {
        &self.messages
    }

    /// List of enums
    pub fn enums(&self) -> &HashMap<String, Enum> {
        &self.enums
    }
}