Trait clap::Clap

pub trait Clap: FromArgMatches + IntoApp + Sized {
    fn parse() -> Self { ... }
    fn try_parse() -> Result<Self, Error> { ... }
    fn parse_from<I, T>(itr: I) -> Self
    where
        I: IntoIterator<Item = T>,
        T: Into<OsString> + Clone,
    { ... }
    fn try_parse_from<I, T>(itr: I) -> Result<Self, Error>
    where
        I: IntoIterator<Item = T>,
        T: Into<OsString> + Clone,
    { ... }
}

The primary one-stop-shop trait used to create an instance of a clap App, conduct the parsing, and turn the resulting ArgMatches back into concrete instance of the user struct.

This trait is primarily a convenience on top of FromArgMatches + IntoApp which uses those two underlying traits to build the two fundamental functions parse which uses the std::env::args_os iterator, and parse_from which allows the consumer to supply the iterator (along with fallible options for each).

Examples

The following example creates a Context struct that would be used throughout the application representing the normalized values coming from the CLI.

/// My super CLI
#[derive(Clap)]
#[clap(name = "demo")]
struct Context {
    /// More verbose output
    #[clap(long)]
    verbose: bool,
    /// An optional name
    #[clap(short, long)]
    name: Option<String>,
}

The equivilant App struct + From implementation:

App::new("demo")
    .about("My super CLI")
    .arg(Arg::new("verbose")
        .long("verbose")
        .about("More verbose output"))
    .arg(Arg::new("name")
        .long("name")
        .long("n")
        .about("An optional name")
        .takes_value(true));

struct Context {
    verbose: bool,
    name: Option<String>,
}

impl From<ArgMatches> for Context {
    fn from(m: ArgMatches) -> Self {
        Context {
            verbose: m.is_present("verbose"),
            name: m.value_of("name").map(|n| n.to_owned()),
        }
    }
}

Provided methods

fn parse() -> Self

Parse from std::env::args_os(), exit on error

fn try_parse() -> Result<Self, Error>

Parse from std::env::args_os(), return Err on error.

fn parse_from<I, T>(itr: I) -> Self where
    I: IntoIterator<Item = T>,
    T: Into<OsString> + Clone, 

Parse from iterator, exit on error

fn try_parse_from<I, T>(itr: I) -> Result<Self, Error> where
    I: IntoIterator<Item = T>,
    T: Into<OsString> + Clone, 

Parse from iterator, return Err on error.

Loading content...

Implementations on Foreign Types

impl<T: Clap> Clap for Box<T>

fn parse() -> Self

fn try_parse() -> Result<Self, Error>

fn parse_from<I, It>(itr: I) -> Self where
    I: IntoIterator<Item = It>,
    It: Into<OsString> + Clone, 

fn try_parse_from<I, It>(itr: I) -> Result<Self, Error> where
    I: IntoIterator<Item = It>,
    It: Into<OsString> + Clone, 

Loading content...

Implementors

Loading content...