Struct meap::parser::Arg

pub struct Arg<A: Arity, H: HasParam, N: NameType> { /* private fields */ }

Implementations

impl<A: Arity, H: HasParam, N: NameType> Arg<A, H, N>

pub fn new(arity: A, has_param: H, name_type: N) -> Self

pub fn desc<S: AsRef<str>>(self, description: S) -> Self

impl<A: Arity, H: HasParam> Arg<A, H, Named>

pub fn name<N: IntoName>(self, name: N) -> Self

impl Arg<Optional, No, Named>

pub fn some_if<T>(self, value: T) -> SomeIf<T>

impl<V: FromStr, T: Display + From<V>> Arg<Optional, YesVia<V, T>, Named>

pub fn with_default(self, value: T) -> WithDefault<V, T, Display<T>>

impl<V: FromStr, T: From<V>> Arg<Optional, YesVia<V, T>, Named>

pub fn with_default_lazy<F: FnOnce() -> T, D: AsRef<str>>( self, description: D, thunk: F ) -> WithDefault<V, T, Lazy<T, F>>

pub fn with_default_desc<D: AsRef<str>>( self, description: D, value: T ) -> WithDefault<V, T, Described<T>>

pub fn with_default_parse<S: AsRef<str>>( self, value: S ) -> WithDefault<V, T, Parsed<V, T>>

Trait Implementations

impl<A: Arity, H: HasParam, N: NameType> Parser for Arg<A, H, N>where Self: SingleArgParser + SingleArgParserHelp,

type Item = <Arg<A, H, N> as SingleArgParser>::SingleArgItem

fn register_low_level(&self, ll: &mut LowLevelParser) -> Result<(), SpecError>

fn parse_low_level( &mut self, ll: &mut LowLevelParserOutput ) -> Result<Self::Item, Box<dyn Error>>

fn update_help(&self, help: &mut Help)

fn parse_args<A: IntoIterator<Item = String>>( self, program_name: String, args: A ) -> Result<Self::Item, (Box<dyn Error>, SpentParser<Self>)>

fn parse_env(self) -> Result<Self::Item, (Box<dyn Error>, SpentParser<Self>)>

fn both<PU: Parser>(self, other: PU) -> Both<Self::Item, PU::Item, Self, PU>

fn map<U, F: FnOnce(Self::Item) -> U>(self, f: F) -> Map<Self::Item, U, F, Self>

fn with_help<N: IntoName>(self, name: N) -> WithHelp<Self::Item, Self>

fn with_help_default(self) -> WithHelp<Self::Item, Self>

fn with_default_general<T>(self, value: T) -> WithDefaultGeneral<T, Self>

fn choose_at_most_one<O: Parser>(self, other: O) -> ChooseAtMostOne<Self, O>

fn with_default_lazy_general<T, F: FnOnce() -> T>( self, f: F ) -> WithDefaultLazyGeneral<T, F, Self>

fn required_general<S: AsRef<str>>( self, error_message: S ) -> RequiredGeneral<Self>

impl<T, A: Arity, H: HasParam, N: NameType> ParserOpt for Arg<A, H, N>where Self: Parser<Item = Option<T>>,

type ItemOpt = T

fn map_opt<U, F: FnOnce(Self::ItemOpt) -> U>( self, f: F ) -> MapOpt<Self::ItemOpt, U, F, Self>

impl SingleArgParser for Arg<Multiple, No, Named>

type SingleArgItem = usize

fn parse_single_arg( &self, ll: &mut LowLevelParserOutput ) -> Result<Self::SingleArgItem, Box<dyn Error>>

impl<V: FromStr, T: From<V>> SingleArgParser for Arg<Multiple, YesVia<V, T>, Named>

type SingleArgItem = Vec<T, Global>

fn parse_single_arg( &self, ll: &mut LowLevelParserOutput ) -> Result<Self::SingleArgItem, Box<dyn Error>>

impl<V: FromStr, T: From<V>> SingleArgParser for Arg<Multiple, YesVia<V, T>, Positional>

type SingleArgItem = Vec<T, Global>

fn parse_single_arg( &self, ll: &mut LowLevelParserOutput ) -> Result<Self::SingleArgItem, Box<dyn Error>>

impl SingleArgParser for Arg<Optional, No, Named>

type SingleArgItem = bool

fn parse_single_arg( &self, ll: &mut LowLevelParserOutput ) -> Result<Self::SingleArgItem, Box<dyn Error>>

impl<V: FromStr, T: From<V>> SingleArgParser for Arg<Optional, YesVia<V, T>, Named>

type SingleArgItem = Option<T>

fn parse_single_arg( &self, ll: &mut LowLevelParserOutput ) -> Result<Self::SingleArgItem, Box<dyn Error>>

impl<V: FromStr, T: From<V>> SingleArgParser for Arg<Optional, YesVia<V, T>, Positional>

type SingleArgItem = Option<T>

fn parse_single_arg( &self, ll: &mut LowLevelParserOutput ) -> Result<Self::SingleArgItem, Box<dyn Error>>

impl<V: FromStr, T: From<V>> SingleArgParser for Arg<Required, YesVia<V, T>, Named>

type SingleArgItem = T

fn parse_single_arg( &self, ll: &mut LowLevelParserOutput ) -> Result<Self::SingleArgItem, Box<dyn Error>>

impl<V: FromStr, T: From<V>> SingleArgParser for Arg<Required, YesVia<V, T>, Positional>

type SingleArgItem = T

fn parse_single_arg( &self, ll: &mut LowLevelParserOutput ) -> Result<Self::SingleArgItem, Box<dyn Error>>

impl<A: Arity, H: HasParam> SingleArgParserHelp for Arg<A, H, Named>

fn help_message(&self) -> ArgHelp

impl<V: FromStr, T: From<V>, A: Arity> SingleArgParserHelp for Arg<A, YesVia<V, T>, Positional>

fn help_message(&self) -> ArgHelp