2 use std
::convert
::From
;
3 use std
::fmt
::{Display, Formatter, Result}
;
5 use std
::result
::Result
as StdResult
;
6 use std
::ffi
::{OsStr, OsString}
;
9 use vec_map
::{self, VecMap}
;
13 use args
::{ArgSettings, ArgKind, Base, Switched, AnyArg, DispOrder}
;
15 #[derive(Default, Clone, Debug)]
17 pub struct FlagBuilder
<'n
, 'e
>
24 impl<'n
, 'e
> FlagBuilder
<'n
, 'e
> {
25 pub fn new(name
: &'n
str) -> Self { FlagBuilder { b: Base::new(name), ..Default::default() }
}
28 impl<'a
, 'b
, 'z
> From
<&'z Arg
<'a
, 'b
>> for FlagBuilder
<'a
, 'b
> {
29 fn from(a
: &'z Arg
<'a
, 'b
>) -> Self {
30 // No need to check for index() or takes_value() as that is handled above
39 impl<'n
, 'e
> Display
for FlagBuilder
<'n
, 'e
> {
40 fn fmt(&self, f
: &mut Formatter
) -> Result
{
41 if let Some(l
) = self.s
.long
{
42 try
!(write
!(f
, "--{}", l
));
44 try
!(write
!(f
, "-{}", self.s
.short
.unwrap()));
51 impl<'n
, 'e
> AnyArg
<'n
, 'e
> for FlagBuilder
<'n
, 'e
> {
52 fn name(&self) -> &'n
str { self.b.name }
53 fn id(&self) -> usize { self.b.id }
54 fn kind(&self) -> ArgKind { ArgKind::Flag }
55 fn overrides(&self) -> Option
<&[&'e
str]> { self.b.overrides.as_ref().map(|o| &o[..]) }
56 fn requires(&self) -> Option
<&[(Option
<&'e
str>, &'n
str)]> { self.b.requires.as_ref().map(|o| &o[..]) }
57 fn blacklist(&self) -> Option
<&[&'e
str]> { self.b.blacklist.as_ref().map(|o| &o[..]) }
58 fn required_unless(&self) -> Option
<&[&'e
str]> { None }
59 fn is_set(&self, s
: ArgSettings
) -> bool { self.b.settings.is_set(s) }
60 fn has_switch(&self) -> bool { true }
61 fn takes_value(&self) -> bool { false }
62 fn set(&mut self, s
: ArgSettings
) { self.b.settings.set(s) }
63 fn max_vals(&self) -> Option
<u64> { None }
64 fn val_names(&self) -> Option
<&VecMap
<&'e
str>> { None }
65 fn num_vals(&self) -> Option
<u64> { None }
66 fn possible_vals(&self) -> Option
<&[&'e
str]> { None }
67 fn validator(&self) -> Option
<&Rc
<Fn(String
) -> StdResult
<(), String
>>> { None }
68 fn validator_os(&self) -> Option
<&Rc
<Fn(&OsStr
) -> StdResult
<(), OsString
>>> { None }
69 fn min_vals(&self) -> Option
<u64> { None }
70 fn short(&self) -> Option
<char> { self.s.short }
71 fn long(&self) -> Option
<&'e
str> { self.s.long }
72 fn val_delim(&self) -> Option
<char> { None }
73 fn help(&self) -> Option
<&'e
str> { self.b.help }
74 fn val_terminator(&self) -> Option
<&'e
str> {None}
75 fn default_val(&self) -> Option
<&'n
str> { None }
76 fn default_vals_ifs(&self) -> Option
<vec_map
::Values
<(&'n
str, Option
<&'e
str>, &'e
str)>> {None}
77 fn longest_filter(&self) -> bool { self.s.long.is_some() }
78 fn aliases(&self) -> Option
<Vec
<&'e
str>> {
79 if let Some(ref aliases
) = self.s
.aliases
{
80 let vis_aliases
: Vec
<_
> = aliases
.iter()
81 .filter_map(|&(n
, v
)| if v { Some(n) }
else { None }
)
83 if vis_aliases
.is_empty() {
94 impl<'n
, 'e
> DispOrder
for FlagBuilder
<'n
, 'e
> {
95 fn disp_ord(&self) -> usize { self.s.disp_ord }
100 use args
::settings
::ArgSettings
;
101 use super::FlagBuilder
;
104 fn flagbuilder_display() {
105 let mut f
= FlagBuilder
::new("flg");
106 f
.b
.settings
.set(ArgSettings
::Multiple
);
107 f
.s
.long
= Some("flag");
109 assert_eq
!(&*format
!("{}", f
), "--flag");
111 let mut f2
= FlagBuilder
::new("flg");
112 f2
.s
.short
= Some('f'
);
114 assert_eq
!(&*format
!("{}", f2
), "-f");
118 fn flagbuilder_display_single_alias() {
119 let mut f
= FlagBuilder
::new("flg");
120 f
.s
.long
= Some("flag");
121 f
.s
.aliases
= Some(vec
![("als", true)]);
123 assert_eq
!(&*format
!("{}", f
), "--flag");
127 fn flagbuilder_display_multiple_aliases() {
128 let mut f
= FlagBuilder
::new("flg");
129 f
.s
.short
= Some('f'
);
131 Some(vec
![("alias_not_visible", false), ("f2", true), ("f3", true), ("f4", true)]);
132 assert_eq
!(&*format
!("{}", f
), "-f");