[−][src]Trait clap_conf::Getter

pub trait Getter<'a, R>: Sized where
    R: PartialEq + Debug, {
type Iter: Iterator<Item = R>;
    fn value<S: AsRef<str>>(&self, s: S, f: Filter) -> Option<R>;

    fn values<S: AsRef<str>>(&self, s: S, f: Filter) -> Option<Self::Iter>;

    fn bool_flag<S: AsRef<str>>(&self, s: S, f: Filter) -> bool { ... }

    fn sub<S: AsRef<str>>(&self, _: S, _: Filter) -> bool { ... }

    fn wrap<R2, F: Fn(R) -> R2>(self, f: F) -> Wrapper<Self, F, R> { ... }

    fn hold<B, RB>(self, b: B) -> Holder<'a, Self, B, R, RB>
    where
        B: Getter<'a, RB>,
        R: From<RB>,
        RB: PartialEq + Debug,
        B::Iter: Iterator<Item = RB>,
    { ... }

    fn grab(&'a self) -> Grabber<'a, Self, R, Self::Iter> { ... }
}

Associated Types

type Iter: Iterator<Item = R>

Loading content...

Required methods

fn value<S: AsRef<str>>(&self, s: S, f: Filter) -> Option<R>

fn values<S: AsRef<str>>(&self, s: S, f: Filter) -> Option<Self::Iter>

Loading content...

Provided methods

fn bool_flag<S: AsRef<str>>(&self, s: S, f: Filter) -> bool

fn sub<S: AsRef<str>>(&self, _: S, _: Filter) -> bool

fn wrap<R2, F: Fn(R) -> R2>(self, f: F) -> Wrapper<Self, F, R>

fn hold<B, RB>(self, b: B) -> Holder<'a, Self, B, R, RB> where
    B: Getter<'a, RB>,
    R: From<RB>,
    RB: PartialEq + Debug,
    B::Iter: Iterator<Item = RB>, 

fn grab(&'a self) -> Grabber<'a, Self, R, Self::Iter>

Loading content...

Implementations on Foreign Types

impl<'a> Getter<'a, String> for Value[src]

type Iter = IntoIter<String>

fn sub<S: AsRef<str>>(&self, _: S, _: Filter) -> bool[src]

fn wrap<R2, F: Fn(R) -> R2>(self, f: F) -> Wrapper<Self, F, R>[src]

fn hold<B, RB>(self, b: B) -> Holder<'a, Self, B, R, RB> where
    B: Getter<'a, RB>,
    R: From<RB>,
    RB: PartialEq + Debug,
    B::Iter: Iterator<Item = RB>, [src]

fn grab(&'a self) -> Grabber<'a, Self, R, Self::Iter>[src]

impl<'a> Getter<'a, &'a Value> for &'a Value[src]

type Iter = Iter<'a, Value>

fn sub<S: AsRef<str>>(&self, _: S, _: Filter) -> bool[src]

fn wrap<R2, F: Fn(R) -> R2>(self, f: F) -> Wrapper<Self, F, R>[src]

fn hold<B, RB>(self, b: B) -> Holder<'a, Self, B, R, RB> where
    B: Getter<'a, RB>,
    R: From<RB>,
    RB: PartialEq + Debug,
    B::Iter: Iterator<Item = RB>, [src]

fn grab(&'a self) -> Grabber<'a, Self, R, Self::Iter>[src]

Loading content...

Implementors

impl<'a> Getter<'a, String> for Enver[src]

type Iter = IntoIter<String>

fn bool_flag<S: AsRef<str>>(&self, s: S, f: Filter) -> bool[src]

fn sub<S: AsRef<str>>(&self, _: S, _: Filter) -> bool[src]

fn wrap<R2, F: Fn(R) -> R2>(self, f: F) -> Wrapper<Self, F, R>[src]

fn hold<B, RB>(self, b: B) -> Holder<'a, Self, B, R, RB> where
    B: Getter<'a, RB>,
    R: From<RB>,
    RB: PartialEq + Debug,
    B::Iter: Iterator<Item = RB>, [src]

fn grab(&'a self) -> Grabber<'a, Self, R, Self::Iter>[src]

impl<'a, 'b> Getter<'a, &'a str> for &'a ArgMatches<'b>[src]

type Iter = Values<'a>

fn wrap<R2, F: Fn(R) -> R2>(self, f: F) -> Wrapper<Self, F, R>[src]

fn hold<B, RB>(self, b: B) -> Holder<'a, Self, B, R, RB> where
    B: Getter<'a, RB>,
    R: From<RB>,
    RB: PartialEq + Debug,
    B::Iter: Iterator<Item = RB>, [src]

fn grab(&'a self) -> Grabber<'a, Self, R, Self::Iter>[src]

impl<'a, A, RA, B, RB> Getter<'a, RA> for Holder<'a, A, B, RA, RB> where
    A: Getter<'a, RA>,
    B: Getter<'a, RB>,
    A::Iter: Iterator<Item = RA>,
    B::Iter: Iterator<Item = RB>,
    RA: PartialEq + Debug,
    RB: PartialEq + Debug,
    RA: From<RB>, [src]

type Iter = OrIter<A::Iter, B::Iter>

fn wrap<R2, F: Fn(R) -> R2>(self, f: F) -> Wrapper<Self, F, R>[src]

fn hold<B, RB>(self, b: B) -> Holder<'a, Self, B, R, RB> where
    B: Getter<'a, RB>,
    R: From<RB>,
    RB: PartialEq + Debug,
    B::Iter: Iterator<Item = RB>, [src]

fn grab(&'a self) -> Grabber<'a, Self, R, Self::Iter>[src]

impl<'a, G, R, F, CR> Getter<'a, R> for Wrapper<G, F, CR> where
    G: Getter<'a, CR>,
    F: Fn(CR) -> R + Clone,
    CR: PartialEq + Debug,
    R: PartialEq + Debug, [src]

type Iter = ConvIter<G::Iter, F>

fn wrap<R2, F: Fn(R) -> R2>(self, f: F) -> Wrapper<Self, F, R>[src]

fn hold<B, RB>(self, b: B) -> Holder<'a, Self, B, R, RB> where
    B: Getter<'a, RB>,
    R: From<RB>,
    RB: PartialEq + Debug,
    B::Iter: Iterator<Item = RB>, [src]

fn grab(&'a self) -> Grabber<'a, Self, R, Self::Iter>[src]

Loading content...