Struct brigadier_rs::parsers::LiteralExecutor

pub struct LiteralExecutor<A, C, S> { /* private fields */ }

Type returned when calling build_exec or build_propagate on a LiteralArgument.

Trait Implementations

impl<S, C> BuildExecute<C, LiteralExecutor<LiteralArgument<S>, C, S>> for LiteralArgument<S>where
    C: TaskLogicNoArgs<S>,

fn build_exec(self, task: C) -> LiteralExecutor<LiteralArgument<S>, C, S>

impl<S, C, T> BuildPropagate<C, T, LiteralExecutor<LiteralArgument<S>, C, S>> for LiteralArgument<S>where
    C: TaskLogic<S, T>,

fn build_propagate(self, task: C) -> LiteralExecutor<LiteralArgument<S>, C, S>

impl<A, C, S> ChildUsage for LiteralExecutor<A, C, S>where
    A: ChildUsage,

type Child = <A as ChildUsage>::Child

Usage that is returned.

fn usage_child(&self) -> Self::Child

Return a new SingleUsage, this represents the path from the root up until this parser.

impl<A, C, S> CommandArgument<S, ()> for LiteralExecutor<A, C, S>where
    A: CommandArgument<S, ()>,

fn parse<'a>(
    &self,
    source: S,
    input: &'a str
) -> IResult<&'a str, (), CommandError<'a>>

Where the magic happens! This is what ends up extracting type A from the raw string input.

impl<A, C, U, S> Execute<S, U> for LiteralExecutor<A, C, S>where
    S: Copy,
    A: CommandArgument<S, ()>,
    C: TaskLogicNoArgs<S, Output = U>,

fn execute<'a>(
    &self,
    source: S,
    input: &'a str
) -> IResult<&'a str, U, CommandError<'a>>

impl<A, C, S> IntoMultipleUsage for LiteralExecutor<A, C, S>where
    A: IntoMultipleUsage,

type Item = <A as IntoMultipleUsage>::Item

The returned MultipleUsage iterator.

fn usage_gen(&self) -> Self::Item

Return a new MultipleUsage based on self (without consuming self).

impl<A, C, T, U, S> Propagate<S, T, U> for LiteralExecutor<A, C, S>where
    T: Copy,
    S: Copy,
    A: CommandArgument<S, ()>,
    C: TaskLogic<S, T, Output = U>,

fn propagate<'a>(
    &self,
    source: S,
    input: &'a str,
    data: T
) -> IResult<&'a str, U, CommandError<'a>>

impl<A, C, S> ThenHelp<S> for LiteralExecutor<A, C, S>

fn help(self, description: &'static str) -> HelpArgument<S, Self>where
    Self: Sized,

Attach this parser to a HelpArgument and a description, the help name will be the usage returned by the root parser.