Struct trivial_argument_parser::ArgumentList

pub struct ArgumentList<'a> {
    pub dangling_values: Vec<String>,
    pub arguments: Vec<Argument>,
    pub parsable_arguments: Vec<&'a mut (dyn HandleableArgument<'a> + 'a)>,
}

Acumulates arguments into list which then can be fed to parse.

Examples

use trivial_argument_parser::{ArgumentList, argument::legacy_argument::*};
let mut args_list = ArgumentList::new();
args_list.append_arg(Argument::new(Some('d'), None, ArgType::Flag).unwrap());
args_list.append_arg(Argument::new(Some('p'), None, ArgType::Value).unwrap());
args_list.append_arg(Argument::new(Some('l'), Some("an-list"), ArgType::ValueList).unwrap());

Fields

dangling_values: Vec<String>

arguments: Vec<Argument>

parsable_arguments: Vec<&'a mut (dyn HandleableArgument<'a> + 'a)>

Implementations

impl<'a> ArgumentList<'a>

pub fn arguments(&self) -> &Vec<Argument>

pub fn new() -> ArgumentList<'a>

Create ArgumentList with empty vector of arguments.

pub fn append_arg(&mut self, argument: Argument)

Append argument to the end of the list.

pub fn append_dangling_value(&mut self, value: &str)

Append dangling values.

pub fn search_by_short_name(&self, name: char) -> Option<&Argument>

Search arguments by short name.

pub fn search_by_short_name_mut(&mut self, name: char) -> Option<&mut Argument>

Search arguments by short name.

pub fn search_by_long_name(&self, name: &str) -> Option<&Argument>

pub fn search_by_long_name_mut(&mut self, name: &str) -> Option<&mut Argument>

Search arguments by long name.

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

Returns vector of all generated dangling values (values not attached to any argument)

pub fn parse_args(&mut self, input: Vec<String>) -> Result<(), String>

Function that does all the parsing. You need to feed user input as an argument. Handles both legacy type arguments and parsable value arguments. When used with mixed type arguments, parsable arguments cannot be accessed before all borrows to ArgumentList are released or it gets dropped.

Examples

use trivial_argument_parser::{
    ArgumentList, args_to_string_vector,
    argument::{
        legacy_argument::*,
        parsable_argument::ParsableValueArgument,
        ArgumentIdentification
    }
};

let mut args_list = ArgumentList::new();
args_list.append_arg(Argument::new(Some('d'), None, ArgType::Flag).unwrap());
let mut argument_str = ParsableValueArgument::new_string(ArgumentIdentification::Long(String::from("hello")));
args_list.register_parsable(&mut argument_str);
args_list.parse_args(args_to_string_vector(std::env::args())).unwrap();
// First read legacy arguments.
args_list.search_by_short_name('n');
// Then access parsable value arguments since last reference was used.
argument_str.first_value();

pub fn register_parsable(&mut self, arg: &'a mut impl HandleableArgument<'a>)

Registers argument mutable borrow to be used while parsing.