Struct Cling 

pub struct Cling<T, S = Build> { /* private fields */ }

A Cling program.

Example:

use cling::prelude::*;

#[derive(Run, Parser, Debug, Clone)]
#[cling(run = "run")]
pub struct App {
    /// Turn debugging information on
    #[arg(short, long, action = ArgAction::Count)]
    pub debug: u8,
}


pub async fn run() {
    println!("Hello, world!");
}

#[tokio::main]
async fn main() -> ClingFinished<App> {
    Cling::parse_and_run().await
}

Implementations

impl<T: Run + Parser> Cling<T, Finished>

pub fn success() -> ClingFinished<T>

Instantiate a successfully finished Cling application. This is useful when you want to return a successful Cling instance from main() directly.

pub fn failed(e: impl Into<CliError>) -> ClingFinished<T>

Instantiate a failed finished Cling application. This is useful when you want to wrap an Error into a Cling instance to be returned from main().

impl<T: Run + Parser> Cling<T, Build>

Parses T with clap and runs until completion

pub fn new(parsed: T) -> Cling<T, Ready>

Create a Cling application from a parsed clap struct.

pub async fn parse_and_run() -> ClingFinished<T>

Parse command line arguments, run the program, and return the finished Cling application. [ClingFinished<T>] can be returned from main() directly which will handle printing errors and exiting with the correct exit code.

pub fn parse() -> Cling<T, Ready>

Parse command line arguments and exit if parsing failed.

pub fn try_parse() -> Result<Cling<T, Ready>, CliError>

Attempt to parse command line arguments and return a runnable Cling application.

pub fn try_parse_from<I, B>(itr: I) -> Result<Cling<T, Ready>, CliError>

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

pub fn try_parse_str(input: &str) -> Result<Cling<T, Ready>, CliError>

Parses input as a UNIX shell command.

Example input string: sub-command --debug=2. Note that the input must omit the CLI binary name, otherwise clap parsing will fail.

pub fn try_parse_str_with_bin_name( bin_name: &str, input: &str, ) -> Result<Cling<T, Ready>, CliError>

pub fn parse_or_exit() -> Cling<T, Ready>

Parse command line arguments and aborts the program if parsing failed.

pub async fn default_run_and_exit() -> !

Parses command line arguments, runs the program and exits afterwards.

impl<T: Run + Parser> Cling<T, Ready>

Cling is now ready to run.

pub async fn run_and_exit(self) -> !

pub async fn run_with_state_and_exit<S>(self, state: S) -> !

where S: Clone + Send + Sync + 'static,

pub async fn run(self) -> ClingFinished<T>

Runs the app with a given state.

pub async fn run_with_state<S>(self, state: S) -> ClingFinished<T>

where S: Clone + Send + Sync + 'static,

impl<T: Run + Parser> Cling<T, Finished>

Cling program has terminated and results can be introspected.

pub fn result_ref(&self) -> &Result<(), CliError>

pub fn result(self) -> Result<(), CliError>

pub fn is_success(&self) -> bool

pub fn is_failure(&self) -> bool

pub fn collected_parameters(&self) -> &CollectedArgs

pub fn collected_arguments_mut(&mut self) -> &mut CollectedArgs