Struct DefaultRepl

pub struct DefaultRepl<C>
where
    C: Debug + Subcommand + IntoEnumIterator,
{ /* private fields */ }

Default implementation for a REPL

Note that you need to define the commands by yourself with a Subcommands enum.

Example

use libpt_cli::repl::{DefaultRepl, Repl};
use clap::Subcommand;
use strum::EnumIter;

#[derive(Subcommand, Debug, EnumIter, Clone)]
enum ReplCommand {
    /// hello world
    Hello,
    /// leave the repl
    Exit,
}

fn main() {
    let mut repl = DefaultRepl::<ReplCommand>::default();
    loop {
        repl.step().unwrap();
        match repl.command().to_owned().unwrap() {
            ReplCommand::Hello => println!("Hello"),
            ReplCommand::Exit => break,
            _ => (),
        }
    }
}

Screenshot

Trait Implementations

impl<C> Args for DefaultRepl<C>

where C: Debug + Subcommand + IntoEnumIterator,

fn group_id() -> Option<Id>

Report the ArgGroup::id for this set of arguments

fn augment_args<'b>(__clap_app: Command) -> Command

Append to Command so it can instantiate Self via FromArgMatches::from_arg_matches_mut

fn augment_args_for_update<'b>(__clap_app: Command) -> Command

Append to Command so it can instantiate self via FromArgMatches::update_from_arg_matches_mut

impl<C> CommandFactory for DefaultRepl<C>

where C: Debug + Subcommand + IntoEnumIterator,

fn command<'b>() -> Command

Build a Command that can instantiate Self.

fn command_for_update<'b>() -> Command

Build a Command that can update self.

impl<C> Debug for DefaultRepl<C>

where C: Debug + Subcommand + IntoEnumIterator,

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

Formats the value using the given formatter.

impl<C> Default for DefaultRepl<C>

where C: Debug + Subcommand + IntoEnumIterator,

fn default() -> Self

Returns the “default value” for a type.

impl<C> FromArgMatches for DefaultRepl<C>

where C: Debug + Subcommand + IntoEnumIterator,

fn from_arg_matches(__clap_arg_matches: &ArgMatches) -> Result<Self, Error>

Instantiate Self from ArgMatches, parsing the arguments as needed.

fn from_arg_matches_mut( __clap_arg_matches: &mut ArgMatches, ) -> Result<Self, Error>

Instantiate Self from ArgMatches, parsing the arguments as needed.

fn update_from_arg_matches( &mut self, __clap_arg_matches: &ArgMatches, ) -> Result<(), Error>

Assign values from ArgMatches to self.

fn update_from_arg_matches_mut( &mut self, __clap_arg_matches: &mut ArgMatches, ) -> Result<(), Error>

Assign values from ArgMatches to self.

impl<C> Parser for DefaultRepl<C>

where C: Debug + Subcommand + IntoEnumIterator,

fn parse() -> Self

Parse from std::env::args_os(), exit on error.

fn try_parse() -> Result<Self, Error>

Parse from std::env::args_os(), return Err on error.

fn parse_from<I, T>(itr: I) -> Self

where I: IntoIterator<Item = T>, T: Into<OsString> + Clone,

Parse from iterator, exit on error.

fn try_parse_from<I, T>(itr: I) -> Result<Self, Error>

where I: IntoIterator<Item = T>, T: Into<OsString> + Clone,

Parse from iterator, return Err on error.

fn update_from<I, T>(&mut self, itr: I)

where I: IntoIterator<Item = T>, T: Into<OsString> + Clone,

Update from iterator, exit on error.

fn try_update_from<I, T>(&mut self, itr: I) -> Result<(), Error>

where I: IntoIterator<Item = T>, T: Into<OsString> + Clone,

Update from iterator, return Err on error.

impl<C> Repl<C> for DefaultRepl<C>

where C: Debug + Subcommand + IntoEnumIterator,

fn new() -> Self

create a new repl

fn command(&self) -> &Option<C>

get the command that was parsed from user input

fn step(&mut self) -> Result<(), Error>

advance the repl to the next iteration of the main loop