ap 0.1.3

Simple argument parsing for the command-line
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

// Copyright (c) 2021 James O. D. Hunt.
//
// SPDX-License-Identifier: Apache-2.0
//

/// A simple example showing how to handle options that need arguments.
use ap::{App, Arg, Args, Handler, Need, Result};

/// The type we will use to handle CLI parsing for this program.
#[derive(Clone, Debug, Default)]
struct MyHandler {
    // Let's keep track of the number of times particular argument are
    // specified on the command-line.
    a_count: usize,
    b_count: usize,
    d_count: usize,

    // Some random fields to demonstrate behaviour
    i: usize,
    v: Vec<String>,
    s: String,
}

impl Handler for &mut MyHandler {
    /// Handler function for handling all CLI arguments this program supports.
    fn handle(&mut self, arg: Arg) -> Result<()> {
        println!("INFO: MyHandler: arg: {:?}", arg);

        match arg.option {
            'a' => self.a_count += 1,
            'b' => self.b_count += 1,
            'd' => self.d_count += 1,
            _ => (),
        };

        self.i += 999;
        self.s = "string value set by handler".into();
        self.v.push("vector value set by handler".into());

        println!("INFO: MyHandler: self: {:?}", self);

        Ok(())
    }
}

fn main() -> Result<()> {
    let mut my_handler = MyHandler::default();

    println!("INFO: Initial value of my handler: {:?}", my_handler);

    let mut args = Args::default();

    // Support "-a <value>" option.
    args.add(Arg::new('a').needs(Need::Argument));

    // Support "-b <value>" option.
    args.add(Arg::new('b').needs(Need::Argument));

    // Support "-d" flag option.
    //
    // Note that since this option does not require an argument,
    // the `arg` passed to the handler will have an empty `value`.
    args.add(Arg::new('d').needs(Need::Nothing));

    let mut app = App::default()
        .help("some text")
        .args(args)
        .handler(Box::new(&mut my_handler));

    // Parse the command-line
    let result = app.parse();

    // XXX: essential!
    drop(app);

    println!("INFO: Final value of my handler: {:?}", my_handler);

    result
}