Struct ArgExt

pub struct ArgExt<A> { /* private fields */ }

Implementations

impl<A> ArgExt<A>

where A: Arg,

pub fn result_map<F, U, E>(self, f: F) -> ArgExt<impl Arg<Item = U, Error = E>>

where E: Debug + Display, F: Fn(Result<A::Item, A::Error>) -> Result<U, E>,

pub fn result_both<B>( self, b: B, ) -> ArgExt<impl Arg<Item = (Result<A::Item, A::Error>, Result<B::Item, B::Error>), Error = Never>>

where B: Arg, Self: Sized,

pub fn both<B>( self, b: B, ) -> ArgExt<impl Arg<Item = (A::Item, B::Item), Error = BothError<A::Error, B::Error>>>

where B: Arg,

pub fn try_map<F, U, E>( self, f: F, ) -> ArgExt<impl Arg<Item = U, Error = TryMapError<A::Error, E>>>

where E: Debug + Display, F: Fn(A::Item) -> Result<U, E>,

pub fn map<F, U>(self, f: F) -> ArgExt<impl Arg<Item = U, Error = A::Error>>

where F: Fn(A::Item) -> U,

Examples found in repository

examples/hello.rs (line 8)

fn main() {
    match free_str()
        .map(|v| v.get(0).cloned())
        .required()
        .just_parse_env_default()
    {
        Ok(name) => println!("Hello, {}!", name),
        Err(msg) => eprintln!("Error: {}", msg),
    }
}

pub fn convert<F, U, E>( self, f: F, ) -> ArgExt<impl Arg<Item = U, Error = TryMapError<A::Error, ConvertFailed<A::Item, E>>>>

where A::Item: Clone + Debug + Display, E: Clone + Debug + Display, F: Fn(A::Item) -> Result<U, E>,

pub fn with_help(self, flag: Flag) -> ArgExt<impl Arg<Item = HelpOr<A::Item>>>

pub fn with_help_default(self) -> ArgExt<impl Arg<Item = HelpOr<A::Item>>>

Examples found in repository

examples/dimensions.rs (line 25)

fn main() {
    match Dimensions::args().with_help_default().parse_env_default() {
        (Ok(HelpOr::Value(dimensions)), _) => println!("{:#?}", dimensions),
        (Ok(HelpOr::Help), usage) => println!("{}", usage.render()),
        (Err(error), usage) => {
            print!("{}\n\n", error);
            print!("{}", usage.render());
            ::std::process::exit(1);
        }
    }
}

pub fn rename( self, name: &str, ) -> ArgExt<impl Arg<Item = A::Item, Error = A::Error>>

pub fn valid(self) -> Valid<A>

impl<A, T> ArgExt<A>

where A: Arg<Item = Option<T>>,

pub fn depend<B, U>( self, b: B, ) -> ArgExt<impl Arg<Item = Option<(T, U)>, Error = DependError<A::Error, B::Error>>>

where B: Arg<Item = Option<U>>,

Examples found in repository

examples/area.rs (line 7)

fn main() {
    match opt::<f32>("", "width", "", "")
        .depend(opt::<f32>("", "height", "", ""))
        .option_map(|(x, y)| (x, y))
        .option_map(|(x, y)| x * y)
        .required()
        .just_parse_env_default()
    {
        Ok(area) => println!("area: {:?}", area),
        Err(e) => panic!("{}", e),
    }
}

pub fn otherwise<U>(self, b: U) -> ArgExt<impl Arg<Item = Either<T, U::Item>>>

where U: Arg,

pub fn option_try_map<F, U, E>( self, f: F, ) -> ArgExt<impl Arg<Item = Option<U>, Error = TryMapError<A::Error, E>>>

where E: Debug + Display, F: Fn(T) -> Result<U, E>,

pub fn option_map<F, U>( self, f: F, ) -> ArgExt<impl Arg<Item = Option<U>, Error = A::Error>>

where F: Fn(T) -> U,

Examples found in repository

examples/area.rs (line 8)

fn main() {
    match opt::<f32>("", "width", "", "")
        .depend(opt::<f32>("", "height", "", ""))
        .option_map(|(x, y)| (x, y))
        .option_map(|(x, y)| x * y)
        .required()
        .just_parse_env_default()
    {
        Ok(area) => println!("area: {:?}", area),
        Err(e) => panic!("{}", e),
    }
}

examples/dimensions.rs (line 18)

    fn args() -> ArgExt<impl Arg<Item = Self>> {
        let window =
            args_all_depend! {
                opt("", "width", "", ""),
                opt("", "height", "", ""),
            }.option_map(|(width, height)| Dimensions::Window { width, height });
        let fullscreen = flag("", "fullscreen", "").some_if(Dimensions::Fullscreen);
        window.either(fullscreen).required()
    }

pub fn either_or_both_any<B, U>( self, b: B, ) -> ArgExt<impl Arg<Item = Option<EitherOrBoth<T, U>>>>

where B: Arg<Item = Option<U>>,

pub fn either_any<B, U>( self, b: B, ) -> ArgExt<impl Arg<Item = Option<Either<T, U>>>>

where B: Arg<Item = Option<U>>,

pub fn either<B>(self, b: B) -> ArgExt<impl Arg<Item = Option<T>>>

where B: Arg<Item = Option<T>>,

Examples found in repository

examples/dimensions.rs (line 20)

    fn args() -> ArgExt<impl Arg<Item = Self>> {
        let window =
            args_all_depend! {
                opt("", "width", "", ""),
                opt("", "height", "", ""),
            }.option_map(|(width, height)| Dimensions::Window { width, height });
        let fullscreen = flag("", "fullscreen", "").some_if(Dimensions::Fullscreen);
        window.either(fullscreen).required()
    }

pub fn with_default(self, t: T) -> ArgExt<impl Arg<Item = T>>

where T: Clone,

pub fn required( self, ) -> ArgExt<impl Arg<Item = T, Error = TryMapError<A::Error, MissingRequiredArg>>>

Examples found in repository

examples/hello.rs (line 9)

fn main() {
    match free_str()
        .map(|v| v.get(0).cloned())
        .required()
        .just_parse_env_default()
    {
        Ok(name) => println!("Hello, {}!", name),
        Err(msg) => eprintln!("Error: {}", msg),
    }
}

examples/area.rs (line 10)

fn main() {
    match opt::<f32>("", "width", "", "")
        .depend(opt::<f32>("", "height", "", ""))
        .option_map(|(x, y)| (x, y))
        .option_map(|(x, y)| x * y)
        .required()
        .just_parse_env_default()
    {
        Ok(area) => println!("area: {:?}", area),
        Err(e) => panic!("{}", e),
    }
}

examples/dimensions.rs (line 20)

    fn args() -> ArgExt<impl Arg<Item = Self>> {
        let window =
            args_all_depend! {
                opt("", "width", "", ""),
                opt("", "height", "", ""),
            }.option_map(|(width, height)| Dimensions::Window { width, height });
        let fullscreen = flag("", "fullscreen", "").some_if(Dimensions::Fullscreen);
        window.either(fullscreen).required()
    }

pub fn option_convert<F, U, E>( self, f: F, ) -> ArgExt<impl Arg<Item = Option<U>, Error = TryMapError<A::Error, ConvertFailed<T, E>>>>

where T: Clone + Debug + Display, E: Clone + Debug + Display, F: Fn(T) -> Result<U, E>,

impl<A> ArgExt<A>

where A: Arg<Item = bool>,

pub fn some_if<T>(self, t: T) -> ArgExt<impl Arg<Item = Option<T>>>

where T: Clone,

Examples found in repository

examples/dimensions.rs (line 19)

    fn args() -> ArgExt<impl Arg<Item = Self>> {
        let window =
            args_all_depend! {
                opt("", "width", "", ""),
                opt("", "height", "", ""),
            }.option_map(|(width, height)| Dimensions::Window { width, height });
        let fullscreen = flag("", "fullscreen", "").some_if(Dimensions::Fullscreen);
        window.either(fullscreen).required()
    }

pub fn unit_option(self) -> ArgExt<impl Arg<Item = Option<()>>>

pub fn unless<U>(self, b: U) -> ArgExt<impl Arg<Item = Option<U::Item>>>

where U: Arg,

impl<A, I> ArgExt<A>

where A: Arg<Item = I>, I: IntoIterator,

pub fn into_iter(self) -> ArgExt<impl Arg<Item = I::IntoIter>>

pub fn vec_try_map<F, U, E>( self, f: F, ) -> ArgExt<impl Arg<Item = Vec<U>, Error = TryMapError<A::Error, E>>>

where E: Debug + Display, F: Fn(I::Item) -> Result<U, E>,

pub fn vec_map<F, U>( self, f: F, ) -> ArgExt<impl Arg<Item = Vec<U>, Error = A::Error>>

where F: Fn(I::Item) -> U,

pub fn vec_convert<F, U, E>( self, f: F, ) -> ArgExt<impl Arg<Item = Vec<U>, Error = TryMapError<A::Error, ConvertFailed<I::Item, E>>>>

where I::Item: Clone + Debug + Display, E: Clone + Debug + Display, F: Fn(I::Item) -> Result<U, E>,

impl<A, I, T, E> ArgExt<A>

where E: Debug + Display, A: Arg<Item = I>, I: IntoIterator<Item = Result<T, E>>,

pub fn vec_ok_or_first_err( self, ) -> ArgExt<impl Arg<Item = Vec<T>, Error = TryMapError<A::Error, E>>>

impl<A, I> ArgExt<A>

where A: Arg<Item = I>, I: Iterator,

pub fn collect<C>(self) -> ArgExt<impl Arg<Item = C>>

where C: FromIterator<I::Item>,

Trait Implementations

impl<A> Arg for ArgExt<A>

where A: Arg,

type Item = <A as Arg>::Item

type Error = <A as Arg>::Error

fn update_switches<S: Switches>(&self, switches: &mut S)

fn name(&self) -> String

fn get(&self, matches: &Matches) -> Result<Self::Item, Self::Error>

fn parse<I>( &self, args: I, ) -> (Result<Self::Item, TopLevelError<Self::Error>>, Usage)

where I: IntoIterator, I::Item: AsRef<OsStr>,

fn validate(&self) -> Option<Invalid>

fn parse_env( &self, program_name: ProgramName, ) -> (Result<Self::Item, TopLevelError<Self::Error>>, UsageWithProgramName)

fn parse_env_default( &self, ) -> (Result<Self::Item, TopLevelError<Self::Error>>, UsageWithProgramName)

fn just_parse<I>( &self, args: I, ) -> Result<Self::Item, TopLevelError<Self::Error>>

where I: IntoIterator, I::Item: AsRef<OsStr>,

fn just_parse_env( &self, program_name: ProgramName, ) -> Result<Self::Item, TopLevelError<Self::Error>>

fn just_parse_env_default( &self, ) -> Result<Self::Item, TopLevelError<Self::Error>>