asn1rs 0.3.1

ASN.1 to Rust, Protobuf and SQL compiler/code generator. Supports ASN.1 UPER
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

use clap::AppSettings;
use clap::{App, Arg};

const ARG_RUST_FIELDS_NOT_PUBLIC: [&str; 5] = [
    "RUST_FIELDS_NOT_PUBLIC",
    "RUST_FIELDS_NOT_PUBLIC",
    "n",
    "rust-fields-not-public",
    "Whether the fields in the generated rust code are marked 'pub'",
];

const ARG_RUST_GETTER_AND_SETTER: [&str; 5] = [
    "RUST_GETTER_AND_SETTER",
    "RUST_GETTER_AND_SETTER",
    "g",
    "rust-getter-and-setter",
    "Whether to generate getter and setter for the fields of the generated rust structs",
];

const ARG_CONVERSION_TARGET: [&str; 5] = [
    "CONVERT_TO",
    "CONVERT_TO",
    "t",
    "convert-to",
    "The target to convert the input files to",
];

pub const CONVERSION_TARGET_RUST: &str = "rust";
pub const CONVERSION_TARGET_PROTO: &str = "proto";
pub const CONVERSION_TARGET_SQL: &str = "sql";
pub const CONVERSION_TARGET_POSSIBLE_VALUES: [&str; 3] = [
    CONVERSION_TARGET_RUST,
    CONVERSION_TARGET_PROTO,
    CONVERSION_TARGET_SQL,
];

#[derive(Debug)]
pub struct Parameters {
    pub rust_fields_not_public: bool,
    pub rust_getter_and_setter: bool,
    pub conversion_target: String,
    pub source_files: Vec<String>,
    pub destination_dir: String,
}

pub fn arg<'a>(values: [&'a str; 5], default: Option<&'a str>) -> Arg<'a, 'a> {
    let mut arg = Arg::with_name(values[0])
        .env(values[0])
        .value_name(values[1])
        .short(values[2])
        .long(values[3])
        //.help(values[4])
        .takes_value(true);

    if let Some(default) = default {
        arg = arg.default_value(default);
    }

    arg
}

pub fn create_argument_parser<'a, 'b>() -> App<'a, 'b> {
    App::new(env!("CARGO_PKG_NAME"))
        .version(env!("CARGO_PKG_VERSION"))
        .author(env!("CARGO_PKG_AUTHORS"))
        .about(env!("CARGO_PKG_DESCRIPTION"))
        .setting(AppSettings::ColoredHelp)
        .arg(arg(ARG_RUST_FIELDS_NOT_PUBLIC, None).takes_value(false))
        .arg(arg(ARG_RUST_GETTER_AND_SETTER, None).takes_value(false))
        .arg(
            arg(ARG_CONVERSION_TARGET, Some(CONVERSION_TARGET_RUST))
                .possible_values(&CONVERSION_TARGET_POSSIBLE_VALUES)
                .next_line_help(true),
        )
        .arg(
            Arg::with_name("DESTINATION_DIR")
                .required(true)
                .multiple(false)
                .value_name("DESTINATION_DIR"),
        )
        .arg(
            Arg::with_name("SOURCE_FILES")
                .required(true)
                .multiple(true)
                .value_name("SOURCE_FILES"),
        )
}

pub fn parse_parameters() -> Parameters {
    let parser = create_argument_parser();
    let matches = parser.get_matches();
    Parameters {
        rust_fields_not_public: matches.is_present(ARG_RUST_FIELDS_NOT_PUBLIC[0]),
        rust_getter_and_setter: matches.is_present(ARG_RUST_GETTER_AND_SETTER[0]),
        conversion_target: matches
            .value_of_lossy(ARG_CONVERSION_TARGET[0])
            .expect("Missing conversion target")
            .to_string(),
        source_files: matches
            .values_of_lossy("SOURCE_FILES")
            .expect("Missing source files"),
        destination_dir: matches
            .value_of_lossy("DESTINATION_DIR")
            .expect("Missing destination directory")
            .to_string(),
    }
}