Files
adler32
aho_corasick
alloc_no_stdlib
alloc_stdlib
ansi_term
assert_matches
atty
backtrace
backtrace_sys
bincode
binjs
binjs_convert_from_json
binjs_decode
binjs_dump
binjs_encode
binjs_es6
binjs_generate_prediction_tables
binjs_generic
binjs_io
binjs_meta
binjs_shared
bitflags
brotli
brotli_decompressor
byteorder
c2_chacha
cfg_if
clap
crc32fast
derive_more
downcast_rs
either
env_logger
failure
flate2
getrandom
humantime
inflector
cases
camelcase
case
classcase
kebabcase
pascalcase
screamingsnakecase
sentencecase
snakecase
tablecase
titlecase
traincase
numbers
deordinalize
ordinalize
suffix
foreignkey
itertools
itoa
lazy_static
libc
log
lzw
memchr
miniz_oxide
nom
ppv_lite86
proc_macro2
quick_error
quote
rand
rand_chacha
rand_core
rand_pcg
range_encoding
regex
regex_syntax
rustc_demangle
ryu
serde
serde_derive
serde_json
smallvec
strsim
syn
termcolor
textwrap
thread_local
unicode_width
unicode_xid
vec_map
weedle
which
xml
 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
use args::{Arg, ArgFlags, ArgSettings};

#[derive(Debug, Clone, Default)]
pub struct Base<'a, 'b>
where
    'a: 'b,
{
    pub name: &'a str,
    pub help: Option<&'b str>,
    pub long_help: Option<&'b str>,
    pub blacklist: Option<Vec<&'a str>>,
    pub settings: ArgFlags,
    pub r_unless: Option<Vec<&'a str>>,
    pub overrides: Option<Vec<&'a str>>,
    pub groups: Option<Vec<&'a str>>,
    pub requires: Option<Vec<(Option<&'b str>, &'a str)>>,
}

impl<'n, 'e> Base<'n, 'e> {
    pub fn new(name: &'n str) -> Self {
        Base {
            name: name,
            ..Default::default()
        }
    }

    pub fn set(&mut self, s: ArgSettings) { self.settings.set(s); }
    pub fn unset(&mut self, s: ArgSettings) { self.settings.unset(s); }
    pub fn is_set(&self, s: ArgSettings) -> bool { self.settings.is_set(s) }
}

impl<'n, 'e, 'z> From<&'z Arg<'n, 'e>> for Base<'n, 'e> {
    fn from(a: &'z Arg<'n, 'e>) -> Self { a.b.clone() }
}

impl<'n, 'e> PartialEq for Base<'n, 'e> {
    fn eq(&self, other: &Base<'n, 'e>) -> bool { self.name == other.name }
}