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}
;
10 use vec_map
::{self, VecMap}
;
14 use args
::{ArgSettings, Base, Switched, AnyArg, DispOrder}
;
16 #[derive(Default, Clone, Debug)]
18 pub struct FlagBuilder
<'n
, 'e
>
25 impl<'n
, 'e
> FlagBuilder
<'n
, 'e
> {
26 pub fn new(name
: &'n
str) -> Self { FlagBuilder { b: Base::new(name), ..Default::default() }
}
29 impl<'a
, 'b
, 'z
> From
<&'z Arg
<'a
, 'b
>> for FlagBuilder
<'a
, 'b
> {
30 fn from(a
: &'z Arg
<'a
, 'b
>) -> Self {
38 impl<'a
, 'b
> From
<Arg
<'a
, 'b
>> for FlagBuilder
<'a
, 'b
> {
39 fn from(mut a
: Arg
<'a
, 'b
>) -> Self {
41 b
: mem
::replace(&mut a
.b
, Base
::default()),
42 s
: mem
::replace(&mut a
.s
, Switched
::default()),
47 impl<'n
, 'e
> Display
for FlagBuilder
<'n
, 'e
> {
48 fn fmt(&self, f
: &mut Formatter
) -> Result
{
49 if let Some(l
) = self.s
.long
{
50 try
!(write
!(f
, "--{}", l
));
52 try
!(write
!(f
, "-{}", self.s
.short
.unwrap()));
59 impl<'n
, 'e
> AnyArg
<'n
, 'e
> for FlagBuilder
<'n
, 'e
> {
60 fn name(&self) -> &'n
str { self.b.name }
61 fn overrides(&self) -> Option
<&[&'e
str]> { self.b.overrides.as_ref().map(|o| &o[..]) }
62 fn requires(&self) -> Option
<&[(Option
<&'e
str>, &'n
str)]> {
63 self.b
.requires
.as_ref().map(|o
| &o
[..])
65 fn blacklist(&self) -> Option
<&[&'e
str]> { self.b.blacklist.as_ref().map(|o| &o[..]) }
66 fn required_unless(&self) -> Option
<&[&'e
str]> { None }
67 fn is_set(&self, s
: ArgSettings
) -> bool { self.b.settings.is_set(s) }
68 fn has_switch(&self) -> bool { true }
69 fn takes_value(&self) -> bool { false }
70 fn set(&mut self, s
: ArgSettings
) { self.b.settings.set(s) }
71 fn max_vals(&self) -> Option
<u64> { None }
72 fn val_names(&self) -> Option
<&VecMap
<&'e
str>> { None }
73 fn num_vals(&self) -> Option
<u64> { None }
74 fn possible_vals(&self) -> Option
<&[&'e
str]> { None }
75 fn validator(&self) -> Option
<&Rc
<Fn(String
) -> StdResult
<(), String
>>> { None }
76 fn validator_os(&self) -> Option
<&Rc
<Fn(&OsStr
) -> StdResult
<(), OsString
>>> { None }
77 fn min_vals(&self) -> Option
<u64> { None }
78 fn short(&self) -> Option
<char> { self.s.short }
79 fn long(&self) -> Option
<&'e
str> { self.s.long }
80 fn val_delim(&self) -> Option
<char> { None }
81 fn help(&self) -> Option
<&'e
str> { self.b.help }
82 fn val_terminator(&self) -> Option
<&'e
str> { None }
83 fn default_val(&self) -> Option
<&'e OsStr
> { None }
84 fn default_vals_ifs(&self) -> Option
<vec_map
::Values
<(&'n
str, Option
<&'e OsStr
>, &'e OsStr
)>> {
87 fn longest_filter(&self) -> bool { self.s.long.is_some() }
88 fn aliases(&self) -> Option
<Vec
<&'e
str>> {
89 if let Some(ref aliases
) = self.s
.aliases
{
90 let vis_aliases
: Vec
<_
> = aliases
.iter()
91 .filter_map(|&(n
, v
)| if v { Some(n) }
else { None }
)
93 if vis_aliases
.is_empty() {
104 impl<'n
, 'e
> DispOrder
for FlagBuilder
<'n
, 'e
> {
105 fn disp_ord(&self) -> usize { self.s.disp_ord }
108 impl<'n
, 'e
> PartialEq
for FlagBuilder
<'n
, 'e
> {
109 fn eq(&self, other
: &FlagBuilder
<'n
, 'e
>) -> bool
{
116 use args
::settings
::ArgSettings
;
117 use super::FlagBuilder
;
120 fn flagbuilder_display() {
121 let mut f
= FlagBuilder
::new("flg");
122 f
.b
.settings
.set(ArgSettings
::Multiple
);
123 f
.s
.long
= Some("flag");
125 assert_eq
!(&*format
!("{}", f
), "--flag");
127 let mut f2
= FlagBuilder
::new("flg");
128 f2
.s
.short
= Some('f'
);
130 assert_eq
!(&*format
!("{}", f2
), "-f");
134 fn flagbuilder_display_single_alias() {
135 let mut f
= FlagBuilder
::new("flg");
136 f
.s
.long
= Some("flag");
137 f
.s
.aliases
= Some(vec
![("als", true)]);
139 assert_eq
!(&*format
!("{}", f
), "--flag");
143 fn flagbuilder_display_multiple_aliases() {
144 let mut f
= FlagBuilder
::new("flg");
145 f
.s
.short
= Some('f'
);
147 Some(vec
![("alias_not_visible", false), ("f2", true), ("f3", true), ("f4", true)]);
148 assert_eq
!(&*format
!("{}", f
), "-f");