Struct Shell

pub struct Shell<'a, T, M: Display, H, I: InputHandler> {
    pub prompt: M,
    pub commands: HashMap<&'a str, Command<T>>,
    pub state: T,
    pub handler: H,
    pub description: String,
    pub input_handler: I,
}

A shell represents a shell for editing commands in.

Here are the generics:

• T: The state.
• M: The prompt. Can be anything that can be printed.
• H: The handler. Should implement either Handler or AsyncHandler, or no functionality is present.
• I: The input handler. Must implement InputHandler

Fields

prompt: M

The shell prompt.

It can be anything which implements Display and can therefore be printed (This allows for prompts that change with the state.)

commands: HashMap<&'a str, Command<T>>

This is a list of commands for the shell. The hashmap key is the name of the command (ie "greet") and the value is a wrapper to the function it corresponds to (as well as help information.)

state: T

This is the state of the shell. This stores any values that you need to be persisted over multiple shell commands. For example it may be a simple counter or maybe a session ID.

handler: H

This is the handler for commands. See the Handler documentation for more.

description: String

This is the description of the shell as a whole. This is displayed when requesting help information.

input_handler: I

The input method

Implementations

impl<'a, T, M: Display> Shell<'a, T, M, DefaultHandler, IO>

pub fn new(state: T, prompt: M) -> Self

Creates a new shell

If you have the rustyline feature enabled use [new_with_handler] to use the rustyline editor.

impl<'a, T, M: Display> Shell<'a, T, M, DefaultAsyncHandler, IO>

pub fn new_async(state: T, prompt: M) -> Self

Available on crate feature async only.

Creates a new shell

If you have the rustyline feature enabled use [new_with_async_handler] to use the rustyline editor.

impl<'a, T, M: Display, H: Handler<T>, I: InputHandler> Shell<'a, T, M, H, I>

pub fn new_with_handler( state: T, prompt: M, handler: H, input_handler: I, ) -> Self

Creates a new shell with the given handler.

pub fn run(&mut self) -> Result<()>

Starts running the shell

impl<'a, T: Send, M: Display, H: AsyncHandler<T>, I: InputHandler> Shell<'a, T, M, H, I>

pub fn new_with_async_handler( state: T, prompt: M, handler: H, input_handler: I, ) -> Self

Available on crate feature async only.

Creates a new shell with the given handler.

pub async fn run_async(&mut self) -> Result<()>

Available on crate feature async only.

Starts running the shell

Trait Implementations

impl<'a, T: Clone, M: Clone + Display, H: Clone, I: Clone + InputHandler> Clone for Shell<'a, T, M, H, I>

fn clone(&self) -> Shell<'a, T, M, H, I>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'f: 't, 't, T: Serialize + for<'a> Deserialize<'a>, M: Display, H: Handler<T>, I: InputHandler> TryFrom<Shell<'f, T, M, H, I>> for App<'t, T, DefaultCommandLineHandler>

Available on crate feature app only.

type Error = Box<dyn Error>

The type returned in the event of a conversion error.

fn try_from(shell: Shell<'f, T, M, H, I>) -> Result<Self, Box<dyn Error>>

Performs the conversion.