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
109

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

use crate::proto::mavlink_messages_v1 as proto;
use crate::protocol::{
    enums::EnumEntryMavCmdFlags, enums::EnumEntryMavCmdParam, errors::ProtoImportError, Deprecated,
};

/// Enum entry specification.
///
/// Used in [`super::Enum`].
#[derive(Debug, Clone)]
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
pub struct EnumEntry {
    value: u32,
    name: String,
    description: String,
    cmd_flags: Option<EnumEntryMavCmdFlags>,
    params: Vec<EnumEntryMavCmdParam>,
    wip: bool,
    deprecated: Option<Deprecated>,
    defined_in: Option<String>,
}

impl EnumEntry {
    /// Default constructor.
    #[allow(clippy::too_many_arguments)]
    pub fn new(
        value: u32,
        name: String,
        description: String,
        cmd_flags: Option<EnumEntryMavCmdFlags>,
        params: Vec<EnumEntryMavCmdParam>,
        wip: bool,
        deprecated: Option<Deprecated>,
        defined_in: Option<String>,
    ) -> Self {
        Self {
            value,
            name,
            description,
            cmd_flags,
            params,
            wip,
            deprecated,
            defined_in,
        }
    }

    /// Converts to Protobuf [`proto::EnumEntry`]
    pub fn to_proto(&self) -> proto::EnumEntry {
        proto::EnumEntry {
            value: self.value,
            name: self.name.clone(),
            description: self.description.clone(),
            cmd_flags: self.cmd_flags.as_ref().map(|c| c.to_proto()),
            params: self.params.iter().map(|p| p.to_proto()).collect(),
            wip: self.wip,
            deprecated: self.deprecated.as_ref().map(|d| d.to_proto()),
            defined_in: self.defined_in.clone(),
        }
    }

    /// Constructs from Protobuf [`proto::EnumEntry`]
    pub fn from_proto(proto: &proto::EnumEntry) -> Result<EnumEntry, ProtoImportError> {
        let mut params = Vec::new();

        for param in &proto.params {
            params.push(EnumEntryMavCmdParam::from_proto(param.clone())?)
        }

        Ok(EnumEntry {
            value: proto.value,
            name: proto.name.clone(),
            description: proto.description.clone(),
            cmd_flags: proto
                .cmd_flags
                .as_ref()
                .map(|flags| EnumEntryMavCmdFlags::from_proto(flags.clone())),
            params,
            wip: proto.wip,
            deprecated: match &proto.deprecated {
                Some(deprecated) => Some(Deprecated::from_proto(deprecated)?),
                None => None,
            },
            defined_in: proto.defined_in.clone(),
        })
    }

    /// Enum entry value.
    pub fn value(&self) -> u32 {
        self.value
    }

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

    /// Enum entry description.
    pub fn description(&self) -> &String {
        &self.description
    }

    /// Deprecation status (if applicable).
    pub fn deprecated(&self) -> &Option<Deprecated> {
        &self.deprecated
    }
}