Struct Command

pub struct Command { /* private fields */ }

Implementations

impl Command

pub fn new( desc: &str, args_info: Vec<CommandArgInfo>, handler: Box<dyn ExecuteCommand>, ) -> Self

Examples found in repository

examples/from_str.rs (lines 80-84)

async fn main() -> anyhow::Result<()> {
    #[rustfmt::skip]
    let mut repl = Repl::builder()
        .add("ls", Command::new(
            "List files in a directory",
            vec![CommandArgInfo::new_with_name(CommandArgType::Custom, "dir")],
            Box::new(LsCommandHandler::new()),
        ))
        .add("ipaddr", Command::new(
            "Just parse and print the given IP address".into(),
            vec![CommandArgInfo::new_with_name(CommandArgType::Custom, "ip")],
            Box::new(IpAddrCommandHandler::new()),
        ))
        .build()
        .context("Failed to create repl")?;

    repl.run().await.context("Critical REPL error")
}

examples/minimal.rs (lines 68-75)

async fn main() -> anyhow::Result<()> {
    let hello_cmd = Command::new(
        "Say hello",
        vec![CommandArgInfo::new_with_name(
            CommandArgType::String,
            "name",
        )],
        Box::new(SayHelloCommandHandler::new()),
    );

    let add_cmd = Command::new(
        "Add X to Y",
        vec![
            CommandArgInfo::new_with_name(CommandArgType::I32, "X"),
            CommandArgInfo::new_with_name(CommandArgType::I32, "Y"),
        ],
        Box::new(AddCommandHandler::new()),
    );

    #[rustfmt::skip]
    let mut repl = Repl::builder()
        .add("hello", hello_cmd)
        .add("add", add_cmd)
        .build()
        .context("Failed to create repl")?;

    repl.run().await.context("Critical REPL error")?;

    Ok(())
}

examples/overload.rs (lines 96-100)

async fn main() -> anyhow::Result<()> {
    #[rustfmt::skip]
    let mut repl = Repl::builder()
        .add("describe", Command::new(
            "Variant 1",
            vec![],
            Box::new(DescribeCommandHandler::new()),
        ))
        .add("describe", Command::new(
        	"Variant 2",
        	vec![
        		CommandArgInfo::new_with_name(CommandArgType::I32, "a"),
        		CommandArgInfo::new_with_name(CommandArgType::I32, "b"),
        	],
        	Box::new(DescribeCommandHandler::new()),
        ))           
        .add("describe", Command::new(
            "Variant 3",
            vec![
        		CommandArgInfo::new_with_name(CommandArgType::I32, "a"),
        		CommandArgInfo::new_with_name(CommandArgType::String, "b"),
        	],
        	Box::new(DescribeCommandHandler::new()),
        ))
        .build()
        .context("Failed to create repl")?;

    repl.run().await.context("Critical REPL error")?;

    Ok(())
}

examples/mut_state.rs (lines 113-120)

async fn main() -> anyhow::Result<()> {
    let outside_x = Rc::new(RefCell::new(String::from("Out x")));

    #[rustfmt::skip]
    let mut repl = Repl::builder()
        .description("Example REPL")
        .prompt("=> ")
        .text_width(60 as usize)
        .add("count", Command::new(
        	"Count from X to Y",
        	vec![
        		CommandArgInfo::new_with_name(CommandArgType::I32, "X"),
        		CommandArgInfo::new_with_name(CommandArgType::I32, "Y"),
        	],
        	Box::new(CountCommandHandler::new()),
        ))
        .add("say", Command::new(
        	"Say X",
        	vec![CommandArgInfo::new_with_name(CommandArgType::F32, "X")],
        	Box::new(SayCommandHandler::new()),
        ))
        .add("outx", Command::new(
        	"Use mutably outside var x. This command has a really long description so we need to wrap it somehow, it is interesting how actually the wrapping will be performed.",
        	vec![],
        	Box::new(OutXCommandHandler::new(outside_x.clone())),
        ))
        .build().context("Failed to create repl")?;

    repl.run().await.context("Critical REPL error")?;

    Ok(())
}

examples/errors.rs (lines 137-141)

async fn main() -> anyhow::Result<()> {
    #[rustfmt::skip]
    let mut repl = Repl::builder()
        .add("ok", Command::new(
            "Run a command that just succeeds",
            vec![],
            Box::new(OkCommandHandler::new()),
        ))
        .add("error", Command::new(
            "Command with recoverable error handled by the REPL",
            vec![CommandArgInfo::new_with_name(CommandArgType::String, "text")],
            Box::new(RecoverableErrorHandler::new()),
        ))
        .add("critical", Command::new(
            "Command returns a critical error that must be handled outside of REPL",
            vec![CommandArgInfo::new_with_name(CommandArgType::String, "text")],
            Box::new(CriticalErrorHandler::new()),
        ))
        .add("roulette", Command::new(
            "Feeling lucky?",
            vec![],
            Box::new(RouletteErrorHandler::new(Instant::now())),
        ))
        .build()
        .context("Failed to create repl")?;

    let repl_res = repl.run().await;
    match repl_res {
        Ok(_) => Ok(()),
        Err(_) => {
            println!("Repl halted. Quitting.");
            Ok(())
        }
    }
}

pub fn execute( &mut self, args: &[&str], ) -> Pin<Box<dyn Future<Output = Result<CommandStatus>> + '_>>

pub fn arg_types(&self) -> Vec<String>

Returns the string description of the argument types