Struct twilight_command_parser::Parser

pub struct Parser<'a> { /* fields omitted */ }

A struct to parse prefixes, commands, and arguments out of messages.

While parsing, the parser takes into account the configuration that it was configured with. This configuration is mutable during runtime via the Parser::config_mut method.

After parsing, you’re given an optional Command: a struct representing a command and its relevant information. Refer to its documentation for more information.

Examples

Using a parser configured with the commands "echo" and "ping" and the prefix "!", parse the message “!echo foo bar baz”:

use twilight_command_parser::{Command, CommandParserConfig, Parser};

let mut config = CommandParserConfig::new();
config.add_command("echo", false);
config.add_command("ping", false);
config.add_prefix("!");

let parser = Parser::new(config);

if let Some(command) = parser.parse("!echo foo bar baz") {
    match command {
        Command { name: "echo", arguments, .. } => {
            let content = arguments.as_str();

            println!("Got a request to echo `{}`", content);
        },
        Command { name: "ping", .. } => {
            println!("Got a ping request");
        },
        _ => {},
    }
}

Implementations

impl<'a> Parser<'a>

pub fn new(config: impl Into<CommandParserConfig<'a>>) -> Self

Creates a new parser from a given configuration.

pub const fn config(&self) -> &CommandParserConfig<'a>

Returns an immutable reference to the configuration.

pub fn config_mut(&mut self) -> &mut CommandParserConfig<'a>

Returns a mutable reference to the configuration.

pub fn parse(&'a self, buf: &'a str) -> Option<Command<'a>>

Parses a command out of a buffer.

If a configured prefix and command are in the buffer, then some Command is returned with them and a lazy iterator of the argument list.

If a matching prefix or command weren’t found, then None is returned.

Refer to the struct-level documentation on how to use this.

pub fn parse_with_prefix(
    &'a self,
    prefix: &'a str,
    buf: &'a str
) -> Option<Command<'a>>

Parse a command out of a buffer with a specific prefix.

Instead of using the list of set prefixes, give a specific prefix to parse the message, this can be used to have a kind of dynamic prefixes.

Example

let mut config = CommandParserConfig::new();
config.add_prefix("!");
config.add_command("echo", false);

let parser = Parser::new(config);

let command = parser.parse_with_prefix("=", "=echo foo")?;

assert_eq!("=", command.prefix);
assert_eq!("echo", command.name);

Trait Implementations

impl<'a> Clone for Parser<'a>

fn clone(&self) -> Parser<'a>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<'a> Debug for Parser<'a>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'a, T: Into<CommandParserConfig<'a>>> From<T> for Parser<'a>

fn from(config: T) -> Self

Performs the conversion.