1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
|
use std::cell::RefCell;
use std::rc::Rc;
use super::{Parse, ParseOption, ParseList, ParseCollect, FromCommandLine};
use super::action::Action;
use super::action::{TypedAction, IArgAction, IArgsAction};
use super::action::ParseResult;
use super::action::ParseResult::{Parsed, Error};
use super::action::Action::{Single, Push, Many};
pub struct ParseAction<'a, T: 'a> {
pub cell: Rc<RefCell<&'a mut T>>,
}
pub struct ParseOptionAction<'a, T: 'a> {
cell: Rc<RefCell<&'a mut Option<T>>>,
}
pub struct ParseListAction<'a, T: 'a> {
cell: Rc<RefCell<&'a mut Vec<T>>>,
}
impl<T: 'static + FromCommandLine> TypedAction<T> for Parse {
fn bind<'x>(&self, cell: Rc<RefCell<&'x mut T>>) -> Action<'x> {
return Single(Box::new(ParseAction { cell: cell }));
}
}
impl<T: 'static + FromCommandLine> TypedAction<Option<T>> for ParseOption {
fn bind<'x>(&self, cell: Rc<RefCell<&'x mut Option<T>>>) -> Action<'x> {
return Single(Box::new(ParseOptionAction { cell: cell }));
}
}
impl<T: 'static + FromCommandLine + Clone> TypedAction<Vec<T>> for ParseList {
fn bind<'x>(&self, cell: Rc<RefCell<&'x mut Vec<T>>>) -> Action<'x> {
return Many(Box::new(ParseListAction { cell: cell }));
}
}
impl<T> TypedAction<Vec<T>> for ParseCollect
where T: 'static + FromCommandLine + Clone
{
fn bind<'x>(&self, cell: Rc<RefCell<&'x mut Vec<T>>>) -> Action<'x> {
return Push(Box::new(ParseListAction { cell: cell }))
}
}
impl<'a, T: FromCommandLine> IArgAction for ParseAction<'a, T> {
fn parse_arg(&self, arg: &str) -> ParseResult {
match FromCommandLine::from_argument(arg) {
Ok(x) => {
**self.cell.borrow_mut() = x;
return Parsed;
}
Err(error) => {
return Error(format!("Bad value {:?}: {}", arg, error));
}
}
}
}
impl<'a, T: FromCommandLine> IArgAction for ParseOptionAction<'a, T> {
fn parse_arg(&self, arg: &str) -> ParseResult {
match FromCommandLine::from_argument(arg) {
Ok(x) => {
**self.cell.borrow_mut() = Some(x);
return Parsed;
}
Err(error) => {
return Error(format!("Bad value {:?}: {}", arg, error));
}
}
}
}
impl<'a, T: FromCommandLine + Clone> IArgsAction for ParseListAction<'a, T> {
fn parse_args(&self, args: &[&str]) -> ParseResult {
let mut result = vec!();
for arg in args.iter() {
match FromCommandLine::from_argument(*arg) {
Ok(x) => {
result.push(x);
}
Err(error) => {
return Error(format!("Bad value {:?}: {}", arg, error));
}
}
}
**self.cell.borrow_mut() = result;
return Parsed;
}
}
|
