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}
;
11 use args
::{AnyArg, ArgSettings, Base, DispOrder, Switched}
;
12 use map
::{self, VecMap}
;
14 #[derive(Default, Clone, Debug)]
16 pub struct FlagBuilder
<'n
, 'e
>
24 impl<'n
, 'e
> FlagBuilder
<'n
, 'e
> {
25 pub fn new(name
: &'n
str) -> Self {
33 impl<'a
, 'b
, 'z
> From
<&'z Arg
<'a
, 'b
>> for FlagBuilder
<'a
, 'b
> {
34 fn from(a
: &'z Arg
<'a
, 'b
>) -> Self {
42 impl<'a
, 'b
> From
<Arg
<'a
, 'b
>> for FlagBuilder
<'a
, 'b
> {
43 fn from(mut a
: Arg
<'a
, 'b
>) -> Self {
45 b
: mem
::replace(&mut a
.b
, Base
::default()),
46 s
: mem
::replace(&mut a
.s
, Switched
::default()),
51 impl<'n
, 'e
> Display
for FlagBuilder
<'n
, 'e
> {
52 fn fmt(&self, f
: &mut Formatter
) -> Result
{
53 if let Some(l
) = self.s
.long
{
54 write
!(f
, "--{}", l
)?
;
56 write
!(f
, "-{}", self.s
.short
.unwrap())?
;
63 impl<'n
, 'e
> AnyArg
<'n
, 'e
> for FlagBuilder
<'n
, 'e
> {
64 fn name(&self) -> &'n
str { self.b.name }
65 fn overrides(&self) -> Option
<&[&'e
str]> { self.b.overrides.as_ref().map(|o| &o[..]) }
66 fn requires(&self) -> Option
<&[(Option
<&'e
str>, &'n
str)]> {
67 self.b
.requires
.as_ref().map(|o
| &o
[..])
69 fn blacklist(&self) -> Option
<&[&'e
str]> { self.b.blacklist.as_ref().map(|o| &o[..]) }
70 fn required_unless(&self) -> Option
<&[&'e
str]> { None }
71 fn is_set(&self, s
: ArgSettings
) -> bool { self.b.settings.is_set(s) }
72 fn has_switch(&self) -> bool { true }
73 fn takes_value(&self) -> bool { false }
74 fn set(&mut self, s
: ArgSettings
) { self.b.settings.set(s) }
75 fn max_vals(&self) -> Option
<u64> { None }
76 fn val_names(&self) -> Option
<&VecMap
<&'e
str>> { None }
77 fn num_vals(&self) -> Option
<u64> { None }
78 fn possible_vals(&self) -> Option
<&[&'e
str]> { None }
79 fn validator(&self) -> Option
<&Rc
<Fn(String
) -> StdResult
<(), String
>>> { None }
80 fn validator_os(&self) -> Option
<&Rc
<Fn(&OsStr
) -> StdResult
<(), OsString
>>> { None }
81 fn min_vals(&self) -> Option
<u64> { None }
82 fn short(&self) -> Option
<char> { self.s.short }
83 fn long(&self) -> Option
<&'e
str> { self.s.long }
84 fn val_delim(&self) -> Option
<char> { None }
85 fn help(&self) -> Option
<&'e
str> { self.b.help }
86 fn long_help(&self) -> Option
<&'e
str> { self.b.long_help }
87 fn val_terminator(&self) -> Option
<&'e
str> { None }
88 fn default_val(&self) -> Option
<&'e OsStr
> { None }
89 fn default_vals_ifs(&self) -> Option
<map
::Values
<(&'n
str, Option
<&'e OsStr
>, &'e OsStr
)>> {
92 fn env
<'s
>(&'s
self) -> Option
<(&'n OsStr
, Option
<&'s OsString
>)> { None }
93 fn longest_filter(&self) -> bool { self.s.long.is_some() }
94 fn aliases(&self) -> Option
<Vec
<&'e
str>> {
95 if let Some(ref aliases
) = self.s
.aliases
{
96 let vis_aliases
: Vec
<_
> = aliases
98 .filter_map(|&(n
, v
)| if v { Some(n) }
else { None }
)
100 if vis_aliases
.is_empty() {
111 impl<'n
, 'e
> DispOrder
for FlagBuilder
<'n
, 'e
> {
112 fn disp_ord(&self) -> usize { self.s.disp_ord }
115 impl<'n
, 'e
> PartialEq
for FlagBuilder
<'n
, 'e
> {
116 fn eq(&self, other
: &FlagBuilder
<'n
, 'e
>) -> bool { self.b == other.b }
121 use args
::settings
::ArgSettings
;
122 use super::FlagBuilder
;
125 fn flagbuilder_display() {
126 let mut f
= FlagBuilder
::new("flg");
127 f
.b
.settings
.set(ArgSettings
::Multiple
);
128 f
.s
.long
= Some("flag");
130 assert_eq
!(&*format
!("{}", f
), "--flag");
132 let mut f2
= FlagBuilder
::new("flg");
133 f2
.s
.short
= Some('f'
);
135 assert_eq
!(&*format
!("{}", f2
), "-f");
139 fn flagbuilder_display_single_alias() {
140 let mut f
= FlagBuilder
::new("flg");
141 f
.s
.long
= Some("flag");
142 f
.s
.aliases
= Some(vec
![("als", true)]);
144 assert_eq
!(&*format
!("{}", f
), "--flag");
148 fn flagbuilder_display_multiple_aliases() {
149 let mut f
= FlagBuilder
::new("flg");
150 f
.s
.short
= Some('f'
);
151 f
.s
.aliases
= Some(vec
![
152 ("alias_not_visible", false),
157 assert_eq
!(&*format
!("{}", f
), "-f");