R-CLIP Documentation

R-CLIP (Rust Command Line Interface Parser) is a command-line parsing library for Rust. It allows you to easily define and manage command-line options and arguments for your Rust applications. This documentation will guide you through the usage of R-CLIP with examples and explanations.

Table of Contents

  1. Introduction
  2. Getting Started
  3. Defining Command-Line Options
  4. Parsing Command-Line Arguments
  5. Example

1. Introduction

R-CLIP is a Rust library that simplifies the process of parsing command-line arguments and options for your applications. With R-CLIP, you can define the options your program supports, parse command-line arguments, and access the values of specified options.

2. Getting Started

Installation

To use R-CLIP in your Rust project, add it as a dependency in your Cargo.toml file:

toml [dependencies] rclip-cmd = "0.0.1"

Importing R-CLIP

In your Rust code, import R-CLIP as follows:

rust extern crate rclip-cmd; use rclip-cmd::{Option, OptionsManager};

3. Defining Command-Line Options

Creating Option Objects

You can define command-line options using the Option struct from R-CLIP. An option is defined by its short name, long name, whether it is required, whether it expects an argument, and a description.

Example option definitions:

rust let option1 = Option::new("v", "version", false, false, "Prints version information"); let option2 = Option::new("f", "file", true, true, "The file to read"); let option3 = Option::new("o", "output", false, true, "The file to write to");

Initializing OptionsManager

After defining your options, you need to create an OptionsManager to manage and parse them. The OptionsManager constructor takes the application name and a vector of Option objects as parameters.

rust let options = vec![option1, option2, option3]; let mut options_manager = OptionsManager::new("MyApp", options);

4. Parsing Command-Line Arguments

Parsing Arguments

You can parse command-line arguments using the parse_options method of the OptionsManager:

rust let args = vec!["-h", "-o", "output.txt"]; let options_result = options_manager.parse_options(args);

Accessing Option Values

After parsing, you can check whether specific options were present and access their argument values if applicable:

rust if options_result.is_ok() { if options_manager.is_present("h") { println!("Help is present"); } if options_manager.is_present("o") { println!("Output file: {}", options_manager.argument("o").unwrap()); } } else { println!("Error: {}", options_result.err().unwrap()); options_manager.print_help(); }

5. Example

Here's an example of using R-CLIP to define and parse command-line options in Rust:

```rust extern crate rclip-cmd; use rclip::{Option, OptionsManager};

fn main() { let option1 = Option::new("v", "version", false, false, "Prints version information"); let option2 = Option::new("f", "file", true, true, "The file to read"); let option3 = Option::new("o", "output", false, true, "The file to write to");

let options = vec![option1, option2, option3];
let mut options_manager = OptionsManager::new("MyApp", options);

let args = vec!["-h", "-o", "output.txt"];
let options_result = options_manager.parse_options(args);

if options_result.is_ok() {
    if options_manager.is_option_present("h") {
        println!("Help is present");
    }
    if options_manager.is_option_present("o") {
        println!("Output file: {}", options_manager.argument("o").unwrap());
    }
} else {
    println!("Error: {}", options_result.err().unwrap());
    options_manager.print_help();
}

} ```

This is a basic example to get you started with R-CLIP. You can customize it for your specific application and use case.

That's it! You've now learned how to use R-CLIP to parse command-line arguments and options in Rust. Feel free to explore more advanced features and customization options provided by R-CLIP in the official documentation.