mavlink-dialects 0.6.7

A set of code generation utilities for MAVLink protocol.
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

use std::env::var;
use std::path::{Path, PathBuf};

use mavinspect::protocol::metadata::DialectTags;
use mavinspect::protocol::{Microservices, Protocol};
use mavspec_rust_gen::{Generator, GeneratorParams};

const DIALECT_LIST: [&str; 15] = [
    "all",
    "ardupilotmega",
    "asluav",
    "avssuas",
    "common",
    "cs_air_link",
    "cubepilot",
    "development",
    "icarous",
    "matrixpilot",
    "minimal",
    "paparazzi",
    "standard",
    "ualberta",
    "uavionix",
];

fn generate_rust_dialects() {
    let protocol = mavlink_message_definitions::protocol()
        .clone()
        .with_dialects_included(&included_dialects(), true, Some(included_tags()));
    let protocol = with_default_dialect(protocol);

    let params = GeneratorParams {
        microservices: enabled_microservices(),
        use_fingerprints: var("CARGO_FEATURE_FINGERPRINTS").is_ok(),
        serde: var("CARGO_FEATURE_SERDE").is_ok(),
        specta: var("CARGO_FEATURE_SPECTA").is_ok(),
        metadata: var("CARGO_FEATURE_METADATA").is_ok(),
        generate_tests: var("CARGO_FEATURE_GENERATE_TESTS").is_ok(),
        internal: true,
    };

    let generator = Generator::new(protocol, &mavlink_out_dir(), params);

    generator
        .generate()
        .expect("Failed to generate MAVLink dialects");
}

fn included_dialects() -> Vec<String> {
    let mut included_dialects: Vec<String> = Default::default();
    for dialect in DIALECT_LIST {
        if var(format!(
            "CARGO_FEATURE_DLCT_{}",
            dialect.to_ascii_uppercase()
        ))
        .is_ok()
        {
            included_dialects.push(dialect.to_string())
        }
    }
    if var("CARGO_CFG_DOCTEST").is_ok() {
        included_dialects.push("minimal".to_string())
    }

    included_dialects
}

fn included_tags() -> DialectTags {
    let mut included_tags: Vec<String> = Default::default();

    if var("CARGO_FEATURE_EXTRA_DIALECTS").is_ok() {
        included_tags.push("extra".to_string());
    }

    if var("CARGO_FEATURE_TEST_DIALECTS").is_ok() {
        included_tags.push("test".to_string());
    }

    DialectTags::new(&included_tags)
}

fn with_default_dialect(protocol: Protocol) -> Protocol {
    for name in mavlink_message_definitions::DEFAULT_DIALECT_SEQUENCE {
        if protocol.contains_dialect_with_canonical_name(name) {
            return protocol.with_default_dialect(name);
        }
    }
    protocol
}

fn enabled_microservices() -> Microservices {
    if var("CARGO_FEATURE_MSRV").is_err() {
        return Microservices::empty();
    }
    let mut microservices = Microservices::empty();

    if var("CARGO_FEATURE_MSRV").is_err() {
        return microservices;
    }

    for (msrv_name, msrv) in Microservices::flags_map() {
        if var(format!("CARGO_FEATURE_MSRV_{}", msrv_name)).is_ok() {
            microservices |= msrv;
        }
    }

    microservices
}

fn out_dir() -> PathBuf {
    Path::new(&var("OUT_DIR").unwrap()).to_path_buf()
}

fn mavlink_out_dir() -> PathBuf {
    out_dir().join("mavlink")
}

fn main() {
    generate_rust_dialects();
}