robotrt-cli 0.1.0-beta.1

RobotRT modular robotics runtime and middleware components.
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

use std::path::PathBuf;

pub fn parse_report_path(args: &[String], default_path: &str) -> Result<PathBuf, String> {
    let mut idx = 0usize;
    while idx < args.len() {
        if args[idx] == "--report" {
            if idx + 1 >= args.len() {
                return Err(String::from("missing value for --report"));
            }
            return Ok(PathBuf::from(&args[idx + 1]));
        }
        idx += 1;
    }
    Ok(PathBuf::from(default_path))
}

pub fn has_flag(args: &[String], flag: &str) -> bool {
    args.iter().any(|arg| arg == flag)
}

pub fn is_help_token(arg: &str) -> bool {
    matches!(arg, "help" | "--help" | "-h")
}

pub fn option_value(args: &[String], option: &str) -> Option<String> {
    let mut idx = 0usize;
    while idx + 1 < args.len() {
        if args[idx] == option {
            return Some(args[idx + 1].clone());
        }
        idx += 1;
    }
    None
}

pub fn parse_usize_option(args: &[String], option: &str, default: usize) -> Result<usize, String> {
    let Some(raw) = option_value(args, option) else {
        return Ok(default);
    };
    raw.parse::<usize>()
        .map_err(|err| format!("invalid value for {option}: {raw} ({err})"))
}

pub fn parse_u64_option(args: &[String], option: &str, default: u64) -> Result<u64, String> {
    let Some(raw) = option_value(args, option) else {
        return Ok(default);
    };
    raw.parse::<u64>()
        .map_err(|err| format!("invalid value for {option}: {raw} ({err})"))
}

pub fn first_positional(args: &[String]) -> Option<String> {
    let mut idx = 0usize;
    while idx < args.len() {
        let token = &args[idx];
        if token.starts_with('-') {
            if option_takes_value(token) {
                idx += 2;
            } else {
                idx += 1;
            }
            continue;
        }
        return Some(token.clone());
    }
    None
}

fn option_takes_value(option: &str) -> bool {
    matches!(
        option,
        "--report"
            | "--endpoint"
            | "--timeout-ms"
            | "--input"
            | "--output"
            | "--bind"
            | "--source"
            | "--count"
            | "--topic"
            | "--domain"
            | "--speed"
            | "--limit"
            | "--iterations"
            | "--interval-ms"
            | "--format"
            | "--alert-template"
            | "--template"
            | "--topic-warn-utilization"
            | "--topic-critical-utilization"
            | "--baseline-report"
            | "--baseline-endpoint"
            | "--baseline-timeout-ms"
            | "--policy"
            | "--project"
            | "--reports"
            | "--endpoints"
            | "--baseline-reports"
            | "--baseline-endpoints"
            | "--input-bag"
            | "--obs-format"
            | "--profile-template"
            | "--target-schema"
            | "--projects"
            | "--projects-file"
            | "--backup"
            | "--scan-root"
            | "--filter-schema"
            | "--filter-template"
            | "--batch-report"
            | "--severity-map"
            | "--file"
            | "--task"
            | "--profile"
            | "--overlay"
            | "--group"
            | "--max-parallel"
            | "--state-file"
            | "--mode"
    )
}