Struct go_flag::FlagSet

pub struct FlagSet<'a> { /* fields omitted */ }

A set of flags. Allows fine control over parse procedure.

Typically you can use the parse function.

Example

let mut force = false;
let mut lines = 10_i32;
let args: Vec<String>;
{
    let mut flags = FlagSet::new();
    flags.add_flag("f", &mut force);
    flags.add_flag("lines", &mut lines);
    args = flags.parse(&["-f", "--lines", "20", "--", "foo"])?;
}
assert_eq!(force, true);
assert_eq!(lines, 20);
assert_eq!(args, vec![String::from("foo")]);

Methods

impl<'a> FlagSet<'a>

pub fn new() -> Self

Creates a new set of flags.

Example

let mut flags = FlagSet::new();

pub fn add_flag(&mut self, name: &'a str, value: &'a mut dyn FlagSetter)

Add a flag to be parsed.

Panics

Panics if the flag of the same name is already registered.

Example

let mut force = false;
let mut flags = FlagSet::new();
flags.add_flag("f", &mut force);

pub fn parse<'b, T: FlagValue, S: AsRef<OsStr>>(
    &mut self,
    args: &'b [S]
) -> Result<Vec<T>, FlagError>

Parses the given arguments.

Returns

Returns the list of positional arguments (remaining arguments).

Positional arguments can also be parsed. You'll typically need Vec<String>, Vec<OsString> or Vec<PathBuf>.

Errors

It returns Err if the given arguments contains invalid flags.

Example

let mut force = false;
let mut flags = FlagSet::new();
flags.add_flag("f", &mut force);
let args: Vec<String> = flags.parse(&["-f", "foo"])?;
assert_eq!(args, vec![String::from("foo")]);

pub fn parse_with_warnings<'b, T: FlagValue, S: AsRef<OsStr>>(
    &mut self,
    args: &'b [S],
    warnings: Option<&mut Vec<FlagWarning>>
) -> Result<Vec<T>, FlagError>

Parses the given arguments, recording warnings issued.

Returns

Returns the list of positional arguments (remaining arguments).

Positional arguments can also be parsed. You'll typically need Vec<String>, Vec<OsString> or Vec<PathBuf>.

Errors

It returns Err if the given arguments contains invalid flags.

Example

let mut warnings = Vec::new();
let mut force = false;
let mut flags = FlagSet::new();
flags.add_flag("f", &mut force);
let args: Vec<String> = flags
    .parse_with_warnings(&["--f", "foo", "-non-flag"], Some(&mut warnings))?;
assert_eq!(args, vec![String::from("foo"), String::from("-non-flag")]);
assert_eq!(warnings[0].to_string(), "short flag with double minuses: --f");
assert_eq!(warnings[1].to_string(), "flag-like syntax appearing after argument: -non-flag");

Trait Implementations

impl<'a> Debug for FlagSet<'a>

fn fmt(&self, f: &mut Formatter) -> Result

Formats the value using the given formatter.