Struct Ref

pub struct Ref<'parser: 'refer, 'refer, T: 'parser> { /* private fields */ }

Implementations

impl<'parser, 'refer, T> Ref<'parser, 'refer, T>

pub fn add_option<'x, A: TypedAction<T>>( &'x mut self, names: &[&'parser str], action: A, help: &'parser str, ) -> &'x mut Ref<'parser, 'refer, T>

Examples found in repository

examples/subcommands.rs (lines 33-34)

fn play_command(verbose: bool, args: Vec<String>) {
    let mut output = "".to_string();
    {
        let mut ap = ArgumentParser::new();
        ap.set_description("Plays a sound");
        ap.refer(&mut output)
            .add_option(&["--output"], Store,
                r#"Output sink to play to"#);
        match ap.parse(args, &mut stdout(), &mut stderr()) {
            Ok(()) =>  {}
            Err(x) => {
                std::process::exit(x);
            }
        }
    }
    println!("Verbosity: {}, Output: {}", verbose, output);
}

fn record_command(verbose: bool, args: Vec<String>) {
    let mut input = "".to_string();
    {
        let mut ap = ArgumentParser::new();
        ap.set_description("Records a sound");
        ap.refer(&mut input)
            .add_option(&["--input"], Store,
                r#"Output source to record from"#);
        match ap.parse(args, &mut stdout(), &mut stderr()) {
            Ok(()) =>  {}
            Err(x) => {
                std::process::exit(x);
            }
        }
    }
    println!("Verbosity: {}, Input: {}", verbose, input);
}

fn main() {
    let mut verbose = false;
    let mut subcommand = Command::play;
    let mut args = vec!();
    {
        let mut ap = ArgumentParser::new();
        ap.set_description("Plays or records sound");
        ap.refer(&mut verbose)
            .add_option(&["-v", "--verbose"], StoreTrue,
            "Be verbose");
        ap.refer(&mut subcommand).required()
            .add_argument("command", Store,
                r#"Command to run (either "play" or "record")"#);
        ap.refer(&mut args)
            .add_argument("arguments", List,
                r#"Arguments for command"#);
        ap.stop_on_first_argument(true);
        ap.parse_args_or_exit();
    }

    args.insert(0, format!("subcommand {:?}", subcommand));
    match subcommand {
        Command::play => play_command(verbose, args),
        Command::record => record_command(verbose, args),
    }
}

examples/greeting.rs (lines 14-15)

fn main() {
    let mut verbose = false;
    let mut name = "World".to_string();
    {
        let mut ap = ArgumentParser::new();
        ap.set_description("Greet somebody.");
        ap.add_option(&["-V", "--version"],
            Print(env!("CARGO_PKG_VERSION").to_string()), "Show version");
        ap.refer(&mut verbose)
            .add_option(&["-v", "--verbose"], StoreTrue,
            "Be verbose");
        ap.refer(&mut name)
            .add_option(&["--name"], Store,
            "Name for the greeting");
        ap.parse_args_or_exit();
    }

    if verbose {
        println!("name is {}", name);
    }
    println!("Hello {}!", name);
}

examples/structure.rs (lines 21-22)

fn main() {
    let mut options = Options {
        verbose: false,
        name: "World".to_string(),
    };
    {
        let mut ap = ArgumentParser::new();
        ap.set_description("Greet somebody.");
        ap.refer(&mut options.verbose)
            .add_option(&["-v", "--verbose"], StoreTrue,
            "Be verbose");
        ap.refer(&mut options.name)
            .add_option(&["--name"], Store,
            "Name for the greeting");
        match ap.parse_args() {
            Ok(()) => {}
            Err(x) => {
                exit(x);
            }
        }
    }

    if options.verbose {
        println!("name is {}", options.name);
    }
    println!("Hello {}!", options.name);
}

pub fn add_argument<'x, A: TypedAction<T>>( &'x mut self, name: &'parser str, action: A, help: &'parser str, ) -> &'x mut Ref<'parser, 'refer, T>

Examples found in repository

examples/subcommands.rs (lines 74-75)

fn main() {
    let mut verbose = false;
    let mut subcommand = Command::play;
    let mut args = vec!();
    {
        let mut ap = ArgumentParser::new();
        ap.set_description("Plays or records sound");
        ap.refer(&mut verbose)
            .add_option(&["-v", "--verbose"], StoreTrue,
            "Be verbose");
        ap.refer(&mut subcommand).required()
            .add_argument("command", Store,
                r#"Command to run (either "play" or "record")"#);
        ap.refer(&mut args)
            .add_argument("arguments", List,
                r#"Arguments for command"#);
        ap.stop_on_first_argument(true);
        ap.parse_args_or_exit();
    }

    args.insert(0, format!("subcommand {:?}", subcommand));
    match subcommand {
        Command::play => play_command(verbose, args),
        Command::record => record_command(verbose, args),
    }
}

pub fn metavar<'x>(&'x mut self, name: &str) -> &'x mut Ref<'parser, 'refer, T>

pub fn required<'x>(&'x mut self) -> &'x mut Ref<'parser, 'refer, T>

Examples found in repository

examples/subcommands.rs (line 73)

fn main() {
    let mut verbose = false;
    let mut subcommand = Command::play;
    let mut args = vec!();
    {
        let mut ap = ArgumentParser::new();
        ap.set_description("Plays or records sound");
        ap.refer(&mut verbose)
            .add_option(&["-v", "--verbose"], StoreTrue,
            "Be verbose");
        ap.refer(&mut subcommand).required()
            .add_argument("command", Store,
                r#"Command to run (either "play" or "record")"#);
        ap.refer(&mut args)
            .add_argument("arguments", List,
                r#"Arguments for command"#);
        ap.stop_on_first_argument(true);
        ap.parse_args_or_exit();
    }

    args.insert(0, format!("subcommand {:?}", subcommand));
    match subcommand {
        Command::play => play_command(verbose, args),
        Command::record => record_command(verbose, args),
    }
}

impl<'parser, 'refer, T: 'static + FromStr> Ref<'parser, 'refer, T>

pub fn envvar<'x>( &'x mut self, varname: &'parser str, ) -> &'x mut Ref<'parser, 'refer, T>