Function getopt::getopt

pub fn getopt(args: &[String], optstring: &str, state: &mut State) -> Result<Opt>

Returns the next option character, if any.

Returns an error if an unexpected option is encountered or if an expected argument is not found.

Parsing stops at the first non-hyphenated argument; or at the first argument matching “-”; or after the first argument matching “–”.

When no more options are available, getopt returns Opt(None, None).

Examples

“-”

use getopt::prelude::*;

// args = ["program", "-", "-a"];
let optstring = "a";
let mut state = State::new();

assert_eq!(Opt(None, None), getopt(&args, optstring, &mut state)?);
assert_eq!("-", args[state.index]);

“–”

use getopt::prelude::*;

// args = ["program", "--", "-a"];
let optstring = "a";
let mut state = State::new();

assert_eq!(Opt(None, None), getopt(&args, optstring, &mut state)?);
assert_eq!("-a", args[state.index]);

Unexpected option:

use getopt::prelude::*;

// args = ["program", "-b"];
let optstring = "a";
let mut state = State::new();

assert_eq!(
    "unknown option -- b".to_string(),
    getopt(&args, optstring, &mut state)
        .unwrap_err()
        .to_string()
);

Missing argument:

use getopt::prelude::*;

// args = ["program", "-a"];
let optstring = "a:";
let mut state = State::new();

assert_eq!(
    "option requires an argument -- a".to_string(),
    getopt(&args, optstring, &mut state)
        .unwrap_err()
        .to_string()
);

A simple example:

use getopt::prelude::*;

// args = ["program", "-abc", "foo"];
let optstring = "ab:c";
let mut state = State::new();

assert_eq!(Opt(Some('a'), None), getopt(&args, optstring, &mut state)?);
assert_eq!(State { index: 1, point: 2 }, state);
assert_eq!(
    Opt(Some('b'), Some("c".to_string())),
    getopt(&args, optstring, &mut state)?
);
assert_eq!(State { index: 2, point: 0 }, state);
assert_eq!(Opt(None, None), getopt(&args, optstring, &mut state)?);
assert_eq!(State { index: 2, point: 0 }, state);
assert_eq!("foo", args[state.index]);

A more realistic example:

use getopt::prelude::*;

// args = ["program", "-abc", "-d", "foo", "-e", "bar"];
let optstring = "ab:cd:e";
let mut state = State::new();

let mut a_flag = false;
let mut b_flag = String::new();
let mut c_flag = false;
let mut d_flag = String::new();
let mut e_flag = false;

loop {
    match getopt(&args, optstring, &mut state)? {
        Opt(None, _) => break,
        Opt(Some('a'), None) => a_flag = true,
        Opt(Some('b'), Some(arg)) => b_flag = arg.clone(),
        Opt(Some('c'), None) => c_flag = true,
        Opt(Some('d'), Some(arg)) => d_flag = arg.clone(),
        Opt(Some('e'), None) => e_flag = true,
        _ => unreachable!(),
    }
}

let args = args.split_off(state.index);

assert_eq!(true, a_flag);
assert_eq!("c", b_flag);
assert_eq!(false, c_flag);
assert_eq!("foo", d_flag);
assert_eq!(true, e_flag);

assert_eq!(1, args.len());
assert_eq!("bar", args.first().unwrap());