     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

    #[doc(hidden)]
    #[allow(missing_debug_implementations)]
    pub struct AppMeta<'b> {
        pub name: String,
        pub bin_name: Option<String>,
        pub author: Option<&'b str>,
        pub version: Option<&'b str>,
        pub about: Option<&'b str>,
        pub more_help: Option<&'b str>,
        pub pre_help: Option<&'b str>,
        pub usage_str: Option<&'b str>,
        pub usage: Option<String>,
        pub help_str: Option<&'b str>,
        pub disp_ord: usize,
        pub template: Option<&'b  str>,
    }

    impl<'b> Default for AppMeta<'b> {
        fn default() -> Self {
            AppMeta {
                name: String::new(),
                author: None,
                about: None,
                more_help: None,
                pre_help: None,
                version: None,
                usage_str: None,
                usage: None,
                bin_name: None,
                help_str: None,
                disp_ord: 999,
                template: None,
            }
        }
    }

    impl<'b> AppMeta<'b> {
        pub fn new() -> Self { Default::default() }
        pub fn with_name(s: String) -> Self {
            AppMeta {
                name: s,
                ..Default::default()
            }
        }
    }

    impl<'b> Clone for AppMeta<'b> {
        fn clone(&self) -> Self {
            AppMeta {
                name: self.name.clone(),
                author: self.author,
                about: self.about,
                more_help: self.more_help,
                pre_help: self.pre_help,
                version: self.version,
                usage_str: self.usage_str,
                usage: self.usage.clone(),
                bin_name: self.bin_name.clone(),
                help_str: self.help_str,
                disp_ord: self.disp_ord,
                template: self.template,
            }
        }
    }

# Help

## Keyboard Shortcuts

?
  Show this help dialog
S
  Focus the search field
⇤
  Move up in search results
⇥
  Move down in search results
⏎
  Go to active search result

## Search Tricks

Prefix searches with a type followed by a colon (e.g. `fn:`) to restrict the search to a given type.

Accepted types are: `fn`, `mod`, `struct`, `enum`, `trait`, `type`, `macro`, and `const`.

Search functions by type signature (e.g. `vec -> usize` or `* -> vec`)