Struct Command 

pub struct Command {
    pub name: String,
    pub arguments: HashMap<String, Box<[String]>>,
}

Represents a parsed command with its name and arguments.

The Command struct holds the parsed command-line arguments in a structured format. It provides convenient methods for accessing arguments with type conversion and error handling.

Examples

use cli_command::{Command, parse_command_string};

let cmd = parse_command_string("serve --port 8080 --host localhost").unwrap();
assert_eq!(cmd.name, "serve");
assert_eq!(cmd.get_argument("port"), Some("8080"));
assert_eq!(cmd.get_argument("host"), Some("localhost"));

Fields

name: String

The command name (first non-flag argument)

arguments: HashMap<String, Box<[String]>>

Parsed arguments as a map of argument names to their values

Implementations

impl Command

pub fn get_argument_nth_parameter_usize( &self, argument: &str, nth: usize, ) -> Option<usize>

Gets the nth parameter of an argument as a usize, if it exists and can be parsed.

Arguments

• argument - The name of the argument
• nth - The zero-based index of the parameter

Returns

• Some(usize) - If the parameter exists and can be parsed as a usize
• None - If the argument doesn’t exist or the parameter can’t be parsed

Examples

use cli_command::{Command, parse_command_string};

let cmd = parse_command_string("--numbers 1 2 3").unwrap();
assert_eq!(cmd.get_argument_nth_parameter_usize("numbers", 0), Some(1));
assert_eq!(cmd.get_argument_nth_parameter_usize("numbers", 1), Some(2));
assert_eq!(cmd.get_argument_nth_parameter_usize("numbers", 5), None);

pub fn get_argument_nth_parameter( &self, argument: &str, nth: usize, ) -> Option<&str>

Gets the nth parameter of an argument as a string slice, if it exists.

Arguments

• argument - The name of the argument
• nth - The zero-based index of the parameter

Returns

• Some(&str) - If the parameter exists
• None - If the argument doesn’t exist or the parameter is out of bounds

Examples

use cli_command::{Command, parse_command_string};

let cmd = parse_command_string("--files a.txt b.txt c.txt").unwrap();
assert_eq!(cmd.get_argument_nth_parameter("files", 0), Some("a.txt"));
assert_eq!(cmd.get_argument_nth_parameter("files", 1), Some("b.txt"));
assert_eq!(cmd.get_argument_nth_parameter("files", 5), None);

pub fn get_argument_nth_param_mandatory( &self, argument: &str, nth: usize, ) -> Result<&str, CliError>

Gets the nth parameter of an argument as a string slice, returning an error if missing.

Arguments

• argument - The name of the argument
• nth - The zero-based index of the parameter

Returns

• Ok(&str) - If the parameter exists
• Err(CliError) - If the argument or parameter is missing

Examples

use cli_command::{Command, parse_command_string};

let cmd = parse_command_string("--files a.txt b.txt").unwrap();
assert_eq!(cmd.get_argument_nth_param_mandatory("files", 0).unwrap(), "a.txt");
assert_eq!(cmd.get_argument_nth_param_mandatory("files", 1).unwrap(), "b.txt");

pub fn get_argument_nth_param_mandatory_usize( &self, argument: &str, nth: usize, ) -> Result<usize, CliError>

Gets the nth parameter of an argument as a usize, returning an error if missing or invalid.

Arguments

• argument - The name of the argument
• nth - The zero-based index of the parameter

Returns

• Ok(usize) - If the parameter exists and can be parsed
• Err(CliError) - If the argument is missing or the parameter can’t be parsed

Examples

use cli_command::{Command, parse_command_string};

let cmd = parse_command_string("--numbers 1 2 3").unwrap();
assert_eq!(cmd.get_argument_nth_param_mandatory_usize("numbers", 0).unwrap(), 1);
assert_eq!(cmd.get_argument_nth_param_mandatory_usize("numbers", 1).unwrap(), 2);

pub fn contains_argument(&self, argument: &str) -> bool

Checks if an argument exists (regardless of whether it has values).

Arguments

• argument - The name of the argument to check

Returns

• true - If the argument exists
• false - If the argument doesn’t exist

Examples

use cli_command::{Command, parse_command_string};

let cmd = parse_command_string("--verbose --port 8080").unwrap();
assert!(cmd.contains_argument("verbose"));
assert!(cmd.contains_argument("port"));
assert!(!cmd.contains_argument("debug"));

Examples found in repository

examples/macro_example.rs (line 43)

fn start_server() -> Result<(), Box<dyn std::error::Error>> {
    let (port, host, workers) = cli_args!(
        port: u16 = 8080,
        host: String = "localhost".to_string(),
        workers: usize = 4
    );

    let cmd = cli_command::parse_command_line()?;
    let ssl = cmd.contains_argument("ssl");
    let verbose = cmd.contains_argument("verbose");
    let config_file = cmd.get_argument("config-file");

    println!("🌐 Server Configuration:");
    println!("   Host: {}", host);
    println!("   Port: {}", port);
    println!("   Workers: {}", workers);
    println!("   SSL: {}", ssl);
    println!("   Verbose: {}", verbose);

    if let Some(config) = config_file {
        println!("   Config file: {}", config);
    }

    println!("✅ Server started successfully on {}:{}", host, port);

    Ok(())
}

examples/file_processor.rs (line 42)

fn compress_files(cmd: &Command) -> Result<(), Box<dyn std::error::Error>> {
    let input_files = cmd.get_argument_mandatory_all("input")?;
    let output_file = cmd.get_argument_mandatory("output")?;

    let compression_level: u8 = cmd.get_argument_or_default("level", 6)?;
    let algorithm = cmd.get_argument_or_default("algorithm", "gzip".to_string())?;
    let recursive = cmd.contains_argument("recursive") || cmd.contains_argument("r");
    let verbose = cmd.contains_argument("verbose") || cmd.contains_argument("v");

    println!("Compression settings:");
    println!("  Input files: {:?}", input_files);
    println!("  Output file: {}", output_file);
    println!("  Compression level: {}", compression_level);
    println!("  Algorithm: {}", algorithm);
    println!("  Recursive: {}", recursive);
    println!("  Verbose: {}", verbose);

    println!(
        "\nCompressing {} files to {}...",
        input_files.len(),
        output_file
    );

    Ok(())
}

fn extract_files(cmd: &Command) -> Result<(), Box<dyn std::error::Error>> {
    let archive_file = cmd.get_argument_mandatory("archive")?;
    let output_dir = cmd.get_argument_or_default("output-dir", ".".to_string())?;
    let overwrite = cmd.contains_argument("overwrite");
    let verbose = cmd.contains_argument("verbose") || cmd.contains_argument("v");

    println!("Extraction settings:");
    println!("  Archive file: {}", archive_file);
    println!("  Output directory: {}", output_dir);
    println!("  Overwrite existing: {}", overwrite);
    println!("  Verbose: {}", verbose);

    println!("\nExtracting {} to {}...", archive_file, output_dir);

    Ok(())
}

fn list_files(cmd: &Command) -> Result<(), Box<dyn std::error::Error>> {
    let archive_file = cmd.get_argument_mandatory("archive")?;
    let detailed = cmd.contains_argument("detailed") || cmd.contains_argument("l");
    let verbose = cmd.contains_argument("verbose") || cmd.contains_argument("v");

    println!("Listing files in: {}", archive_file);
    println!("Detailed view: {}", detailed);
    println!("Verbose: {}", verbose);

    println!("\nArchive contents:");
    println!("  file1.txt (1024 bytes)");
    println!("  file2.txt (2048 bytes)");
    println!("  subdir/file3.txt (512 bytes)");

    Ok(())
}

examples/simple_server.rs (line 35)

fn start_server(cmd: &Command) -> Result<(), Box<dyn std::error::Error>> {
    let host: IpAddr = cmd.get_argument_or_default("host", Ipv4Addr::new(127, 0, 0, 1).into())?;
    let port: u16 = cmd.get_argument_or_default("port", 8080)?;
    let workers: usize = cmd.get_argument_or_default("workers", 4)?;
    let max_connections: usize = cmd.get_argument_or_default("max-connections", 1000)?;

    let enable_ssl = cmd.contains_argument("ssl");
    let enable_compression = cmd.contains_argument("compression");
    let verbose = cmd.contains_argument("verbose") || cmd.contains_argument("v");

    let config_file = cmd.get_argument("config");

    let addr = SocketAddr::new(host, port);

    println!("Server configuration:");
    println!("  Address: {}", addr);
    println!("  Workers: {}", workers);
    println!("  Max connections: {}", max_connections);
    println!("  SSL enabled: {}", enable_ssl);
    println!("  Compression enabled: {}", enable_compression);
    println!("  Verbose logging: {}", verbose);

    if let Some(config) = config_file {
        println!("  Config file: {}", config);
    }

    println!("\nServer would start on {} with {} workers", addr, workers);

    Ok(())
}

examples/simple_macro_test.rs (line 20)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    println!("🔧 Simple CLI Args Macro Demo");
    println!();

    let (name, age, email, port) = cli_args!(
        name: String = "Anonymous".to_string(),
        age: u32 = 25,
        email: String = "user@example.com".to_string(),
        port: u16 = 8080
    );

    let cmd = parse_command_line()?;
    let is_active = cmd.contains_argument("is-active");

    println!("📋 Parsed Arguments:");
    println!("   Name: {}", name);
    println!("   Age: {}", age);
    println!("   Email: {}", email);
    println!("   Active: {}", is_active);
    println!("   Port: {}", port);

    println!();
    println!("✨ Notice how the cli_args! macro eliminated this boilerplate:");
    println!("   let name = cmd.get_argument_or_default(\"name\", \"Anonymous\".to_string())?;");
    println!("   let age = cmd.get_argument_or_default(\"age\", 25)?;");
    println!(
        "   let email = cmd.get_argument_or_default(\"email\", \"user@example.com\".to_string())?;"
    );
    println!("   let is_active = cmd.get_argument_or_default(\"is_active\", true)?;");
    println!("   let port = cmd.get_argument_or_default(\"port\", 8080)?;");

    println!();
    println!("🚀 Try running with different arguments:");
    println!("   cargo run --example simple_macro_test -- --name Alice --age 30 --port 3000");
    println!("   cargo run --example simple_macro_test -- --name Bob --email bob@company.com --is-active false");

    Ok(())
}

pub fn get_argument(&self, argument: &str) -> Option<&str>

Gets the first parameter of an argument as a string slice, if it exists.

Arguments

• argument - The name of the argument

Returns

• Some(&str) - If the argument exists and has at least one parameter
• None - If the argument doesn’t exist or has no parameters

Examples

use cli_command::{Command, parse_command_string};

let cmd = parse_command_string("--host localhost --port 8080").unwrap();
assert_eq!(cmd.get_argument("host"), Some("localhost"));
assert_eq!(cmd.get_argument("port"), Some("8080"));
assert_eq!(cmd.get_argument("debug"), None);

Examples found in repository

examples/cli_match_example.rs (line 48)

fn start_server() -> Result<(), Box<dyn std::error::Error>> {
    let (port, host, workers, ssl, verbose) = cli_args!(
        port: u16 = 8080,
        host: String = "localhost".to_string(),
        workers: usize = 4,
        ssl: bool = false,
        verbose: bool = false
    );

    let cmd = cli_command::parse_command_line()?;
    let config_file = cmd.get_argument("config-file");

    println!("🌐 Server Configuration:");
    println!("   Host: {}", host);
    println!("   Port: {}", port);
    println!("   Workers: {}", workers);
    println!("   SSL: {}", ssl);
    println!("   Verbose: {}", verbose);

    if let Some(config) = config_file {
        println!("   Config file: {}", config);
    }

    println!("✅ Server started successfully on {}:{}", host, port);

    Ok(())
}

/// Start a client using both cli_match! and cli_args! macros
fn start_client() -> Result<(), Box<dyn std::error::Error>> {
    let (timeout, retries, server_url) = cli_args!(
        timeout: u64 = 30,
        retries: u32 = 3,
        server_url: String = "http://localhost:8080".to_string()
    );

    let cmd = cli_command::parse_command_line()?;
    let username = cmd.get_argument("username");
    let password = cmd.get_argument("password");

    println!("📡 Client Configuration:");
    println!("   Server URL: {}", server_url);
    println!("   Timeout: {}s", timeout);
    println!("   Retries: {}", retries);

    if let Some(user) = username {
        println!("   Username: {}", user);
    }

    if let Some(pass) = password {
        println!("   Password: {}", "*".repeat(pass.len()));
    }

    println!("✅ Client connected to server successfully");

    Ok(())
}

examples/macro_example.rs (line 45)

fn start_server() -> Result<(), Box<dyn std::error::Error>> {
    let (port, host, workers) = cli_args!(
        port: u16 = 8080,
        host: String = "localhost".to_string(),
        workers: usize = 4
    );

    let cmd = cli_command::parse_command_line()?;
    let ssl = cmd.contains_argument("ssl");
    let verbose = cmd.contains_argument("verbose");
    let config_file = cmd.get_argument("config-file");

    println!("🌐 Server Configuration:");
    println!("   Host: {}", host);
    println!("   Port: {}", port);
    println!("   Workers: {}", workers);
    println!("   SSL: {}", ssl);
    println!("   Verbose: {}", verbose);

    if let Some(config) = config_file {
        println!("   Config file: {}", config);
    }

    println!("✅ Server started successfully on {}:{}", host, port);

    Ok(())
}

/// Start a client using the cli_args! macro for argument extraction
fn start_client() -> Result<(), Box<dyn std::error::Error>> {
    let (timeout, retries) = cli_args!(
        timeout: u64 = 30,
        retries: u32 = 3
    );

    let cmd = cli_command::parse_command_line()?;
    let server_url =
        cmd.get_argument_or_default("server-url", "http://localhost:8080".to_string())?;
    let username = cmd.get_argument("username");
    let password = cmd.get_argument("password");

    println!("📡 Client Configuration:");
    println!("   Server URL: {}", server_url);
    println!("   Timeout: {}s", timeout);
    println!("   Retries: {}", retries);

    if let Some(user) = username {
        println!("   Username: {}", user);
    }

    if let Some(pass) = password {
        println!("   Password: {}", "*".repeat(pass.len()));
    }

    println!("✅ Client connected to server successfully");

    Ok(())
}

examples/simple_server.rs (line 39)

fn start_server(cmd: &Command) -> Result<(), Box<dyn std::error::Error>> {
    let host: IpAddr = cmd.get_argument_or_default("host", Ipv4Addr::new(127, 0, 0, 1).into())?;
    let port: u16 = cmd.get_argument_or_default("port", 8080)?;
    let workers: usize = cmd.get_argument_or_default("workers", 4)?;
    let max_connections: usize = cmd.get_argument_or_default("max-connections", 1000)?;

    let enable_ssl = cmd.contains_argument("ssl");
    let enable_compression = cmd.contains_argument("compression");
    let verbose = cmd.contains_argument("verbose") || cmd.contains_argument("v");

    let config_file = cmd.get_argument("config");

    let addr = SocketAddr::new(host, port);

    println!("Server configuration:");
    println!("  Address: {}", addr);
    println!("  Workers: {}", workers);
    println!("  Max connections: {}", max_connections);
    println!("  SSL enabled: {}", enable_ssl);
    println!("  Compression enabled: {}", enable_compression);
    println!("  Verbose logging: {}", verbose);

    if let Some(config) = config_file {
        println!("  Config file: {}", config);
    }

    println!("\nServer would start on {} with {} workers", addr, workers);

    Ok(())
}

pub fn get_argument_mandatory(&self, argument: &str) -> Result<&str, CliError>

Gets the first parameter of an argument as a string slice, returning an error if missing.

Arguments

• argument - The name of the argument

Returns

• Ok(&str) - If the argument exists and has at least one parameter
• Err(CliError) - If the argument is missing

Examples

use cli_command::{Command, parse_command_string};

let cmd = parse_command_string("--host localhost").unwrap();
assert_eq!(cmd.get_argument_mandatory("host").unwrap(), "localhost");

Examples found in repository

examples/file_processor.rs (line 38)

fn compress_files(cmd: &Command) -> Result<(), Box<dyn std::error::Error>> {
    let input_files = cmd.get_argument_mandatory_all("input")?;
    let output_file = cmd.get_argument_mandatory("output")?;

    let compression_level: u8 = cmd.get_argument_or_default("level", 6)?;
    let algorithm = cmd.get_argument_or_default("algorithm", "gzip".to_string())?;
    let recursive = cmd.contains_argument("recursive") || cmd.contains_argument("r");
    let verbose = cmd.contains_argument("verbose") || cmd.contains_argument("v");

    println!("Compression settings:");
    println!("  Input files: {:?}", input_files);
    println!("  Output file: {}", output_file);
    println!("  Compression level: {}", compression_level);
    println!("  Algorithm: {}", algorithm);
    println!("  Recursive: {}", recursive);
    println!("  Verbose: {}", verbose);

    println!(
        "\nCompressing {} files to {}...",
        input_files.len(),
        output_file
    );

    Ok(())
}

fn extract_files(cmd: &Command) -> Result<(), Box<dyn std::error::Error>> {
    let archive_file = cmd.get_argument_mandatory("archive")?;
    let output_dir = cmd.get_argument_or_default("output-dir", ".".to_string())?;
    let overwrite = cmd.contains_argument("overwrite");
    let verbose = cmd.contains_argument("verbose") || cmd.contains_argument("v");

    println!("Extraction settings:");
    println!("  Archive file: {}", archive_file);
    println!("  Output directory: {}", output_dir);
    println!("  Overwrite existing: {}", overwrite);
    println!("  Verbose: {}", verbose);

    println!("\nExtracting {} to {}...", archive_file, output_dir);

    Ok(())
}

fn list_files(cmd: &Command) -> Result<(), Box<dyn std::error::Error>> {
    let archive_file = cmd.get_argument_mandatory("archive")?;
    let detailed = cmd.contains_argument("detailed") || cmd.contains_argument("l");
    let verbose = cmd.contains_argument("verbose") || cmd.contains_argument("v");

    println!("Listing files in: {}", archive_file);
    println!("Detailed view: {}", detailed);
    println!("Verbose: {}", verbose);

    println!("\nArchive contents:");
    println!("  file1.txt (1024 bytes)");
    println!("  file2.txt (2048 bytes)");
    println!("  subdir/file3.txt (512 bytes)");

    Ok(())
}

pub fn get_argument_mandatory_usize( &self, argument: &str, ) -> Result<usize, CliError>

Gets the first parameter of an argument as a usize, returning an error if missing or invalid.

Arguments

• argument - The name of the argument

Returns

• Ok(usize) - If the argument exists and can be parsed as a usize
• Err(CliError) - If the argument is missing or can’t be parsed

Examples

use cli_command::{Command, parse_command_string};

let cmd = parse_command_string("--port 8080").unwrap();
assert_eq!(cmd.get_argument_mandatory_usize("port").unwrap(), 8080);

pub fn get_argument_usize(&self, argument: &str) -> Option<usize>

Gets the first parameter of an argument as a usize, if it exists and can be parsed.

Arguments

• argument - The name of the argument

Returns

• Some(usize) - If the argument exists and can be parsed as a usize
• None - If the argument doesn’t exist or can’t be parsed

Examples

use cli_command::{Command, parse_command_string};

let cmd = parse_command_string("--port 8080 --workers 4").unwrap();
assert_eq!(cmd.get_argument_usize("port"), Some(8080));
assert_eq!(cmd.get_argument_usize("workers"), Some(4));
assert_eq!(cmd.get_argument_usize("debug"), None);

pub fn get_argument_i32(&self, argument: &str) -> Option<i32>

Gets the first parameter of an argument as an i32, if it exists and can be parsed.

Arguments

• argument - The name of the argument

Returns

• Some(i32) - If the argument exists and can be parsed as an i32
• None - If the argument doesn’t exist or can’t be parsed

Examples

use cli_command::{Command, parse_command_string};

let cmd = parse_command_string("--port 8080 --timeout 30").unwrap();
assert_eq!(cmd.get_argument_i32("port"), Some(8080));
assert_eq!(cmd.get_argument_i32("timeout"), Some(30));
assert_eq!(cmd.get_argument_i32("debug"), None);

pub fn get_argument_f64(&self, argument: &str) -> Option<f64>

Gets the first parameter of an argument as a f64, if it exists and can be parsed.

Arguments

• argument - The name of the argument

Returns

• Some(f64) - If the argument exists and can be parsed as an f64
• None - If the argument doesn’t exist or can’t be parsed

Examples

use cli_command::{Command, parse_command_string};

let cmd = parse_command_string("--ratio 0.5 --threshold 1.23").unwrap();
assert_eq!(cmd.get_argument_f64("ratio"), Some(0.5));
assert_eq!(cmd.get_argument_f64("threshold"), Some(1.23));
assert_eq!(cmd.get_argument_f64("debug"), None);

pub fn get_argument_bool(&self, argument: &str) -> Option<bool>

Gets the first parameter of an argument as a bool, if it exists and can be parsed.

Arguments

• argument - The name of the argument

Returns

• Some(bool) - If the argument exists and can be parsed as a bool
• None - If the argument doesn’t exist or can’t be parsed

Examples

use cli_command::{Command, parse_command_string};

let cmd = parse_command_string("--enabled true --disabled false").unwrap();
assert_eq!(cmd.get_argument_bool("enabled"), Some(true));
assert_eq!(cmd.get_argument_bool("disabled"), Some(false));
assert_eq!(cmd.get_argument_bool("debug"), None);

pub fn get_argument_all(&self, argument: &str) -> Option<&Box<[String]>>

Gets all parameters of an argument as a slice of strings, if it exists.

Arguments

• argument - The name of the argument

Returns

• Some(&Box<[String]>) - If the argument exists
• None - If the argument doesn’t exist

Examples

use cli_command::{Command, parse_command_string};

let cmd = parse_command_string("--files a.txt b.txt c.txt").unwrap();
let files = cmd.get_argument_all("files").unwrap();
assert_eq!(files.len(), 3);
assert_eq!(&files[0], "a.txt");
assert_eq!(&files[1], "b.txt");
assert_eq!(&files[2], "c.txt");

pub fn get_argument_mandatory_all( &self, argument: &str, ) -> Result<&Box<[String]>, CliError>

Gets all parameters of an argument as a slice of strings, returning an error if missing.

Arguments

• argument - The name of the argument

Returns

• Ok(&Box<[String]>) - If the argument exists
• Err(CliError) - If the argument is missing

Examples

use cli_command::{Command, parse_command_string};

let cmd = parse_command_string("--files a.txt b.txt").unwrap();
let files = cmd.get_argument_mandatory_all("files").unwrap();
assert_eq!(files.len(), 2);

Examples found in repository

examples/file_processor.rs (line 37)

fn compress_files(cmd: &Command) -> Result<(), Box<dyn std::error::Error>> {
    let input_files = cmd.get_argument_mandatory_all("input")?;
    let output_file = cmd.get_argument_mandatory("output")?;

    let compression_level: u8 = cmd.get_argument_or_default("level", 6)?;
    let algorithm = cmd.get_argument_or_default("algorithm", "gzip".to_string())?;
    let recursive = cmd.contains_argument("recursive") || cmd.contains_argument("r");
    let verbose = cmd.contains_argument("verbose") || cmd.contains_argument("v");

    println!("Compression settings:");
    println!("  Input files: {:?}", input_files);
    println!("  Output file: {}", output_file);
    println!("  Compression level: {}", compression_level);
    println!("  Algorithm: {}", algorithm);
    println!("  Recursive: {}", recursive);
    println!("  Verbose: {}", verbose);

    println!(
        "\nCompressing {} files to {}...",
        input_files.len(),
        output_file
    );

    Ok(())
}

pub fn get_argument_or_default<T>( &self, argument: &str, default: T, ) -> Result<T, CliError>

where T: FromStr, T::Err: Error + Send + Sync + 'static,

Gets the first parameter of an argument with type conversion, or returns a default value if missing.

This method attempts to parse the argument value as the specified type T. If the argument is missing, it returns the provided default value instead of an error.

Arguments

• argument - The name of the argument
• default - The default value to return if the argument is missing

Returns

• Ok(T) - If the argument exists and can be parsed, or if missing (returns default)
• Err(CliError) - If the argument exists but can’t be parsed as the target type

Examples

use cli_command::{Command, parse_command_string};

let cmd = parse_command_string("--port 8080").unwrap();
let port: u16 = cmd.get_argument_or_default("port", 3000).unwrap();
assert_eq!(port, 8080);

let timeout: u64 = cmd.get_argument_or_default("timeout", 30).unwrap();
assert_eq!(timeout, 30); // Uses default since timeout not provided

Examples found in repository

examples/macro_example.rs (line 72)

fn start_client() -> Result<(), Box<dyn std::error::Error>> {
    let (timeout, retries) = cli_args!(
        timeout: u64 = 30,
        retries: u32 = 3
    );

    let cmd = cli_command::parse_command_line()?;
    let server_url =
        cmd.get_argument_or_default("server-url", "http://localhost:8080".to_string())?;
    let username = cmd.get_argument("username");
    let password = cmd.get_argument("password");

    println!("📡 Client Configuration:");
    println!("   Server URL: {}", server_url);
    println!("   Timeout: {}s", timeout);
    println!("   Retries: {}", retries);

    if let Some(user) = username {
        println!("   Username: {}", user);
    }

    if let Some(pass) = password {
        println!("   Password: {}", "*".repeat(pass.len()));
    }

    println!("✅ Client connected to server successfully");

    Ok(())
}

examples/file_processor.rs (line 40)

fn compress_files(cmd: &Command) -> Result<(), Box<dyn std::error::Error>> {
    let input_files = cmd.get_argument_mandatory_all("input")?;
    let output_file = cmd.get_argument_mandatory("output")?;

    let compression_level: u8 = cmd.get_argument_or_default("level", 6)?;
    let algorithm = cmd.get_argument_or_default("algorithm", "gzip".to_string())?;
    let recursive = cmd.contains_argument("recursive") || cmd.contains_argument("r");
    let verbose = cmd.contains_argument("verbose") || cmd.contains_argument("v");

    println!("Compression settings:");
    println!("  Input files: {:?}", input_files);
    println!("  Output file: {}", output_file);
    println!("  Compression level: {}", compression_level);
    println!("  Algorithm: {}", algorithm);
    println!("  Recursive: {}", recursive);
    println!("  Verbose: {}", verbose);

    println!(
        "\nCompressing {} files to {}...",
        input_files.len(),
        output_file
    );

    Ok(())
}

fn extract_files(cmd: &Command) -> Result<(), Box<dyn std::error::Error>> {
    let archive_file = cmd.get_argument_mandatory("archive")?;
    let output_dir = cmd.get_argument_or_default("output-dir", ".".to_string())?;
    let overwrite = cmd.contains_argument("overwrite");
    let verbose = cmd.contains_argument("verbose") || cmd.contains_argument("v");

    println!("Extraction settings:");
    println!("  Archive file: {}", archive_file);
    println!("  Output directory: {}", output_dir);
    println!("  Overwrite existing: {}", overwrite);
    println!("  Verbose: {}", verbose);

    println!("\nExtracting {} to {}...", archive_file, output_dir);

    Ok(())
}

examples/simple_server.rs (line 30)

fn start_server(cmd: &Command) -> Result<(), Box<dyn std::error::Error>> {
    let host: IpAddr = cmd.get_argument_or_default("host", Ipv4Addr::new(127, 0, 0, 1).into())?;
    let port: u16 = cmd.get_argument_or_default("port", 8080)?;
    let workers: usize = cmd.get_argument_or_default("workers", 4)?;
    let max_connections: usize = cmd.get_argument_or_default("max-connections", 1000)?;

    let enable_ssl = cmd.contains_argument("ssl");
    let enable_compression = cmd.contains_argument("compression");
    let verbose = cmd.contains_argument("verbose") || cmd.contains_argument("v");

    let config_file = cmd.get_argument("config");

    let addr = SocketAddr::new(host, port);

    println!("Server configuration:");
    println!("  Address: {}", addr);
    println!("  Workers: {}", workers);
    println!("  Max connections: {}", max_connections);
    println!("  SSL enabled: {}", enable_ssl);
    println!("  Compression enabled: {}", enable_compression);
    println!("  Verbose logging: {}", verbose);

    if let Some(config) = config_file {
        println!("  Config file: {}", config);
    }

    println!("\nServer would start on {} with {} workers", addr, workers);

    Ok(())
}

Trait Implementations

impl Clone for Command

fn clone(&self) -> Command

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Command

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

Formats the value using the given formatter.