Struct bpaf::Named

pub struct Named { /* private fields */ }

A named thing used to create Flag, Switch or Argument.

Implementations

impl Named

pub fn short(self, short: char) -> Self

Add a short name to a flag/switch/argument

You can specify it multiple times, items past the first one represent hidden aliases.

let switch: Parser<bool> =
    short('f')
        .short('F')
        .long("flag")
        .help("a flag that does a thing")
        .switch();

pub fn long(self, long: &'static str) -> Self

Add a long name to a flag/switch/argument

You can specify it multiple times, items past the first one will become hidden aliases.

let switch: Parser<bool> =
    short('f')
        .long("flag")
        .long("Flag")
        .help("a flag that does a thing")
        .switch();

pub fn env(self, variable: &'static str) -> Self

Environment variable fallback

If named value is not present - try to fallback to this environment variable. You can specify it multiple times, items past the first one will become hidden aliases.

let key = short('k')
           .long("key")
           .env("API_KEY")
           .help("Use this API key to access the API")
           .argument("KEY");

pub fn help<M>(self, help: M) -> Self where
    M: Into<String>, 

Add a help message to a flag/switch/argument

let switch: Parser<bool> =
    short('f')
        .long("flag")
        .help("a flag that does a thing")
        .switch();

pub fn switch(self) -> Parser<bool>

Simple boolean flag

Parser produces true if flag is present in a command line or false otherwise

let switch: Parser<bool> =
    short('f')
        .long("flag")
        .help("a flag that does a thing")
        .switch();

pub fn flag<T>(self, present: T, absent: T) -> Parser<T> where
    T: Clone + 'static, 

Flag with custom present/absent values

Parser produces present if flag is present in a command line or absent otherwise

#[derive(Clone)]
enum Flag {
    Absent,
    Present,
}
let switch: Parser<Flag> =
    short('f')
        .long("flag")
        .help("a flag that does a thing")
        .flag(Flag::Present, Flag::Absent);

pub fn req_flag<T>(self, present: T) -> Parser<T> where
    T: Clone + 'static, 

Required flag with custom value

Parser produces a value if present and fails otherwise. Designed to be used with combination of other parser(s).

#[derive(Clone)]
enum Decision {
    On,
    Off,
    Undecided
}
let on = long("on").req_flag(Decision::On);
let off = long("off").req_flag(Decision::Off);
// Requires user to specify either `--on` or `--off`
let state: Parser<Decision> = on.or_else(off).fallback(Decision::Undecided);

// counts how many times flag `-v` is given on a command line
let verbosity: Parser<usize> = short('v').req_flag(()).many().map(|v| v.len());

pub fn argument(self, metavar: &'static str) -> Parser<String>

Named argument that can be encoded as String

Argument must be present (but can be made into Option using optional) and it must contain only valid unicode characters. For OS specific encoding see argument_os.

let arg = short('n').long("name").argument("NAME");

pub fn argument_os(self, metavar: &'static str) -> Parser<OsString>

Named argument in OS specific encoding

Argument must be present but can be made into Option using optional. If you prefer to panic on non utf8 encoding see argument.

let arg = short('n').long("name").argument_os("NAME");

Trait Implementations

impl Clone for Named

fn clone(&self) -> Named

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Named

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

Formats the value using the given formatter.