Struct CommandBuilder 

pub struct CommandBuilder { /* private fields */ }

A command builder.

Commands are comprised of a tree of command nodes, a command name, an optional command description, and a handler system. Handler systems may behave like normal systems, except that they must receive the In<CommandContext> parameter and return CommandResult.

The order that command nodes (argument or subcommand group) are added with their respective with_ methods determines the order they are parsed in, and therefore the layout of the command.

Implementations

impl CommandBuilder

pub fn new<S, M>(name: &str, description: Option<&str>, handler: S) -> Self

where S: IntoSystem<In<CommandContext>, CommandResult, M> + Send + Sync + 'static,

Create a new command.

• name: The name of this command. This currently may not begin with a digit ('0'..='9') and may otherwise only contain the characters 'a'..='z', 'A'..='Z', '0'..='9', and _. This limitation may be lifted in the future.
• description: An optional description for this subcommand
• handler: The handler system for this command. This must be a system that takes at minimum an In<CommandContext>.

A common error when using this with a closure as a handler is when one omits the type of In<CommandContext>, e.g.:

use bevy_commodore::CommandBuilder;

// rust cannot correctly determine the type of the closure when the type of `v` is omitted.
CommandBuilder::new("empty", None, |v| todo!());

In this case, simply add the type to the closure:

use bevy::prelude::In;
use bevy_commodore::{CommandBuilder, CommandContext};

CommandBuilder::new("empty", None, |v: In<CommandContext>| todo!());

Panics

Panics if the name does not match the above specified predicate.

pub fn with_argument<T: Argument>( &mut self, name: &str, description: Option<&str>, optional: bool, ) -> &mut Self

Add an argument node to this command. Arguments are stored - and therefore parsed - in the order that they are passed to this function.

T must be an argument type that has been registered to the plugin.

pub fn with_subcommands<B>(&mut self, builder: B) -> &mut Self

where B: FnOnce(&mut SubcommandGroupBuilder),

Add a subcommand group node to this command. A subcommand group node is a group of subcommands, from which the user may select one.

This method takes a closure which is passed a &mut SubcommandGroupBuilder.

Panics

This method panics if no subcommands were added to the SubcommandGroupBuilder.

Trait Implementations

impl Hash for CommandBuilder

fn hash<H: Hasher>(&self, state: &mut H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for CommandBuilder

fn eq(&self, other: &Self) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Eq for CommandBuilder