mirror of
https://github.com/fluencelabs/wasmer
synced 2025-04-25 10:22:19 +00:00
591 lines
95 KiB
HTML
591 lines
95 KiB
HTML
<!DOCTYPE html><html lang="en"><head><meta charset="utf-8"><meta name="viewport" content="width=device-width, initial-scale=1.0"><meta name="generator" content="rustdoc"><meta name="description" content="API documentation for the Rust `AppSettings` enum in crate `clap`."><meta name="keywords" content="rust, rustlang, rust-lang, AppSettings"><title>clap::AppSettings - Rust</title><link rel="stylesheet" type="text/css" href="../normalize.css"><link rel="stylesheet" type="text/css" href="../rustdoc.css" id="mainThemeStyle"><link rel="stylesheet" type="text/css" href="../dark.css"><link rel="stylesheet" type="text/css" href="../light.css" id="themeStyle"><script src="../storage.js"></script><noscript><link rel="stylesheet" href="../noscript.css"></noscript><link rel="shortcut icon" href="../favicon.ico"><style type="text/css">#crate-search{background-image:url("../down-arrow.svg");}</style></head><body class="rustdoc enum"><!--[if lte IE 8]><div class="warning">This old browser is unsupported and will most likely display funky things.</div><![endif]--><nav class="sidebar"><div class="sidebar-menu">☰</div><a href='../clap/index.html'><div class='logo-container'><img src='../rust-logo.png' alt='logo'></div></a><p class='location'>Enum AppSettings</p><div class="sidebar-elems"><div class="block items"><a class="sidebar-title" href="#variants">Variants</a><div class="sidebar-links"><a href="#variant.AllowInvalidUtf8">AllowInvalidUtf8</a><a href="#variant.AllArgsOverrideSelf">AllArgsOverrideSelf</a><a href="#variant.AllowLeadingHyphen">AllowLeadingHyphen</a><a href="#variant.AllowNegativeNumbers">AllowNegativeNumbers</a><a href="#variant.AllowMissingPositional">AllowMissingPositional</a><a href="#variant.AllowExternalSubcommands">AllowExternalSubcommands</a><a href="#variant.ArgsNegateSubcommands">ArgsNegateSubcommands</a><a href="#variant.ArgRequiredElseHelp">ArgRequiredElseHelp</a><a href="#variant.ColoredHelp">ColoredHelp</a><a href="#variant.ColorAuto">ColorAuto</a><a href="#variant.ColorAlways">ColorAlways</a><a href="#variant.ColorNever">ColorNever</a><a href="#variant.DontCollapseArgsInUsage">DontCollapseArgsInUsage</a><a href="#variant.DontDelimitTrailingValues">DontDelimitTrailingValues</a><a href="#variant.DisableHelpFlags">DisableHelpFlags</a><a href="#variant.DisableHelpSubcommand">DisableHelpSubcommand</a><a href="#variant.DisableVersion">DisableVersion</a><a href="#variant.DeriveDisplayOrder">DeriveDisplayOrder</a><a href="#variant.GlobalVersion">GlobalVersion</a><a href="#variant.Hidden">Hidden</a><a href="#variant.HidePossibleValuesInHelp">HidePossibleValuesInHelp</a><a href="#variant.InferSubcommands">InferSubcommands</a><a href="#variant.NoBinaryName">NoBinaryName</a><a href="#variant.NextLineHelp">NextLineHelp</a><a href="#variant.PropagateGlobalValuesDown">PropagateGlobalValuesDown</a><a href="#variant.SubcommandsNegateReqs">SubcommandsNegateReqs</a><a href="#variant.SubcommandRequiredElseHelp">SubcommandRequiredElseHelp</a><a href="#variant.StrictUtf8">StrictUtf8</a><a href="#variant.SubcommandRequired">SubcommandRequired</a><a href="#variant.TrailingVarArg">TrailingVarArg</a><a href="#variant.UnifiedHelpMessage">UnifiedHelpMessage</a><a href="#variant.VersionlessSubcommands">VersionlessSubcommands</a><a href="#variant.WaitOnError">WaitOnError</a></div><a class="sidebar-title" href="#implementations">Trait Implementations</a><div class="sidebar-links"><a href="#impl-Clone">Clone</a><a href="#impl-Copy">Copy</a><a href="#impl-Debug">Debug</a><a href="#impl-FromStr">FromStr</a><a href="#impl-PartialEq%3CAppSettings%3E">PartialEq<AppSettings></a></div><a class="sidebar-title" href="#synthetic-implementations">Auto Trait Implementations</a><div class="sidebar-links"><a href="#impl-RefUnwindSafe">RefUnwindSafe</a><a href="#impl-Send">Send</a><a href="#impl-Sync">Sync</a><a href="#impl-Unpin">Unpin</a><a href="#impl-UnwindSafe">UnwindSafe</a></div><a class="sidebar-title" href="#blanket-implementations">Blanket Implementations</a><div class="sidebar-links"><a href="#impl-Any">Any</a><a href="#impl-Borrow%3CT%3E">Borrow<T></a><a href="#impl-BorrowMut%3CT%3E">BorrowMut<T></a><a href="#impl-From%3CT%3E">From<T></a><a href="#impl-Into%3CU%3E">Into<U></a><a href="#impl-ToOwned">ToOwned</a><a href="#impl-TryFrom%3CU%3E">TryFrom<U></a><a href="#impl-TryInto%3CU%3E">TryInto<U></a></div></div><p class='location'><a href='index.html'>clap</a></p><script>window.sidebarCurrent = {name: 'AppSettings', ty: 'enum', relpath: ''};</script><script defer src="sidebar-items.js"></script></div></nav><div class="theme-picker"><button id="theme-picker" aria-label="Pick another theme!"><img src="../brush.svg" width="18" alt="Pick another theme!"></button><div id="theme-choices"></div></div><script src="../theme.js"></script><nav class="sub"><form class="search-form js-only"><div class="search-container"><div><select id="crate-search"><option value="All crates">All crates</option></select><input class="search-input" name="search" autocomplete="off" spellcheck="false" placeholder="Click or press ‘S’ to search, ‘?’ for more options…" type="search"></div><a id="settings-menu" href="../settings.html"><img src="../wheel.svg" width="18" alt="Change settings"></a></div></form></nav><section id="main" class="content"><h1 class='fqn'><span class='out-of-band'><span id='render-detail'><a id="toggle-all-docs" href="javascript:void(0)" title="collapse all docs">[<span class='inner'>−</span>]</a></span><a class='srclink' href='../src/clap/app/settings.rs.html#130-980' title='goto source code'>[src]</a></span><span class='in-band'>Enum <a href='index.html'>clap</a>::<wbr><a class="enum" href=''>AppSettings</a></span></h1><div class="docblock type-decl hidden-by-usual-hider"><pre class='rust enum'>pub enum AppSettings {
|
||
AllowInvalidUtf8,
|
||
AllArgsOverrideSelf,
|
||
AllowLeadingHyphen,
|
||
AllowNegativeNumbers,
|
||
AllowMissingPositional,
|
||
AllowExternalSubcommands,
|
||
ArgsNegateSubcommands,
|
||
ArgRequiredElseHelp,
|
||
ColoredHelp,
|
||
ColorAuto,
|
||
ColorAlways,
|
||
ColorNever,
|
||
DontCollapseArgsInUsage,
|
||
DontDelimitTrailingValues,
|
||
DisableHelpFlags,
|
||
DisableHelpSubcommand,
|
||
DisableVersion,
|
||
DeriveDisplayOrder,
|
||
GlobalVersion,
|
||
Hidden,
|
||
HidePossibleValuesInHelp,
|
||
InferSubcommands,
|
||
NoBinaryName,
|
||
NextLineHelp,
|
||
PropagateGlobalValuesDown,
|
||
SubcommandsNegateReqs,
|
||
SubcommandRequiredElseHelp,
|
||
StrictUtf8,
|
||
SubcommandRequired,
|
||
TrailingVarArg,
|
||
UnifiedHelpMessage,
|
||
VersionlessSubcommands,
|
||
WaitOnError,
|
||
// some variants omitted
|
||
}</pre></div><div class='docblock'><p>Application level settings, which affect how <a href="./struct.App.html"><code>App</code></a> operates</p>
|
||
<p><strong>NOTE:</strong> When these settings are used, they apply only to current command, and are <em>not</em>
|
||
propagated down or up through child or parent subcommands</p>
|
||
</div><h2 id='variants' class='variants small-section-header'>
|
||
Variants<a href='#variants' class='anchor'></a></h2>
|
||
<span id="variant.AllowInvalidUtf8" class="variant small-section-header"><a href="#variant.AllowInvalidUtf8" class="anchor field"></a><code id='AllowInvalidUtf8.v'>AllowInvalidUtf8</code></span><div class='docblock'><p>Specifies that any invalid UTF-8 code points should <em>not</em> be treated as an error.
|
||
This is the default behavior of <code>clap</code>.</p>
|
||
<p><strong>NOTE:</strong> Using argument values with invalid UTF-8 code points requires using
|
||
<a href="./struct.ArgMatches.html#method.os_value_of"><code>ArgMatches::os_value_of</code></a>, <a href="./struct.ArgMatches.html#method.os_values_of"><code>ArgMatches::os_values_of</code></a>, <a href="./struct.ArgMatches.html#method.lossy_value_of"><code>ArgMatches::lossy_value_of</code></a>,
|
||
or <a href="./struct.ArgMatches.html#method.lossy_values_of"><code>ArgMatches::lossy_values_of</code></a> for those particular arguments which may contain invalid
|
||
UTF-8 values</p>
|
||
<p><strong>NOTE:</strong> This rule only applies to argument values, as flags, options, and
|
||
<a href="./struct.SubCommand.html"><code>SubCommand</code></a>s themselves only allow valid UTF-8 code points.</p>
|
||
<h1 id="platform-specific" class="section-header"><a href="#platform-specific">Platform Specific</a></h1>
|
||
<p>Non Windows systems only</p>
|
||
<h1 id="examples" class="section-header"><a href="#examples">Examples</a></h1>
|
||
<div class="example-wrap"><pre class="rust rust-example-rendered">
|
||
<span class="kw">use</span> <span class="ident">std</span>::<span class="ident">ffi</span>::<span class="ident">OsString</span>;
|
||
<span class="kw">use</span> <span class="ident">std</span>::<span class="ident">os</span>::<span class="ident">unix</span>::<span class="ident">ffi</span>::{<span class="ident">OsStrExt</span>,<span class="ident">OsStringExt</span>};
|
||
|
||
<span class="kw">let</span> <span class="ident">r</span> <span class="op">=</span> <span class="ident">App</span>::<span class="ident">new</span>(<span class="string">"myprog"</span>)
|
||
<span class="comment">//.setting(AppSettings::AllowInvalidUtf8)</span>
|
||
.<span class="ident">arg_from_usage</span>(<span class="string">"<arg> 'some positional arg'"</span>)
|
||
.<span class="ident">get_matches_from_safe</span>(
|
||
<span class="macro">vec</span><span class="macro">!</span>[
|
||
<span class="ident">OsString</span>::<span class="ident">from</span>(<span class="string">"myprog"</span>),
|
||
<span class="ident">OsString</span>::<span class="ident">from_vec</span>(<span class="macro">vec</span><span class="macro">!</span>[<span class="number">0xe9</span>])]);
|
||
|
||
<span class="macro">assert</span><span class="macro">!</span>(<span class="ident">r</span>.<span class="ident">is_ok</span>());
|
||
<span class="kw">let</span> <span class="ident">m</span> <span class="op">=</span> <span class="ident">r</span>.<span class="ident">unwrap</span>();
|
||
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">m</span>.<span class="ident">value_of_os</span>(<span class="string">"arg"</span>).<span class="ident">unwrap</span>().<span class="ident">as_bytes</span>(), <span class="kw-2">&</span>[<span class="number">0xe9</span>]);</pre></div>
|
||
</div><span id="variant.AllArgsOverrideSelf" class="variant small-section-header"><a href="#variant.AllArgsOverrideSelf" class="anchor field"></a><code id='AllArgsOverrideSelf.v'>AllArgsOverrideSelf</code></span><div class='docblock'><p>Essentially sets [<code>Arg::overrides_with("itself")</code>] for all arguments.</p>
|
||
<p><strong>WARNING:</strong> Positional arguments cannot override themselves (or we would never be able
|
||
to advance to the next positional). This setting ignores positional arguments.
|
||
[<code>Arg::overrides_with("itself")</code>]: ./struct.Arg.html#method.overrides_with</p>
|
||
</div><span id="variant.AllowLeadingHyphen" class="variant small-section-header"><a href="#variant.AllowLeadingHyphen" class="anchor field"></a><code id='AllowLeadingHyphen.v'>AllowLeadingHyphen</code></span><div class='docblock'><p>Specifies that leading hyphens are allowed in argument <em>values</em>, such as negative numbers
|
||
like <code>-10</code>. (which would otherwise be parsed as another flag or option)</p>
|
||
<p><strong>NOTE:</strong> Use this setting with caution as it silences certain circumstances which would
|
||
otherwise be an error (such as accidentally forgetting to specify a value for leading
|
||
option). It is preferred to set this on a per argument basis, via <a href="./struct.Arg.html#method.allow_hyphen_values"><code>Arg::allow_hyphen_values</code></a></p>
|
||
<h1 id="examples-1" class="section-header"><a href="#examples-1">Examples</a></h1>
|
||
<div class="example-wrap"><pre class="rust rust-example-rendered">
|
||
<span class="comment">// Imagine you needed to represent negative numbers as well, such as -10</span>
|
||
<span class="kw">let</span> <span class="ident">m</span> <span class="op">=</span> <span class="ident">App</span>::<span class="ident">new</span>(<span class="string">"nums"</span>)
|
||
.<span class="ident">setting</span>(<span class="ident">AppSettings</span>::<span class="ident">AllowLeadingHyphen</span>)
|
||
.<span class="ident">arg</span>(<span class="ident">Arg</span>::<span class="ident">with_name</span>(<span class="string">"neg"</span>).<span class="ident">index</span>(<span class="number">1</span>))
|
||
.<span class="ident">get_matches_from</span>(<span class="macro">vec</span><span class="macro">!</span>[
|
||
<span class="string">"nums"</span>, <span class="string">"-20"</span>
|
||
]);
|
||
|
||
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">m</span>.<span class="ident">value_of</span>(<span class="string">"neg"</span>), <span class="prelude-val">Some</span>(<span class="string">"-20"</span>));</pre></div>
|
||
</div><span id="variant.AllowNegativeNumbers" class="variant small-section-header"><a href="#variant.AllowNegativeNumbers" class="anchor field"></a><code id='AllowNegativeNumbers.v'>AllowNegativeNumbers</code></span><div class='docblock'><p>Allows negative numbers to pass as values. This is similar to
|
||
<code>AllowLeadingHyphen</code> except that it only allows numbers, all
|
||
other undefined leading hyphens will fail to parse.</p>
|
||
<h1 id="examples-2" class="section-header"><a href="#examples-2">Examples</a></h1>
|
||
<div class="example-wrap"><pre class="rust rust-example-rendered">
|
||
<span class="kw">let</span> <span class="ident">res</span> <span class="op">=</span> <span class="ident">App</span>::<span class="ident">new</span>(<span class="string">"myprog"</span>)
|
||
.<span class="ident">version</span>(<span class="string">"v1.1"</span>)
|
||
.<span class="ident">setting</span>(<span class="ident">AppSettings</span>::<span class="ident">AllowNegativeNumbers</span>)
|
||
.<span class="ident">arg</span>(<span class="ident">Arg</span>::<span class="ident">with_name</span>(<span class="string">"num"</span>))
|
||
.<span class="ident">get_matches_from_safe</span>(<span class="macro">vec</span><span class="macro">!</span>[
|
||
<span class="string">"myprog"</span>, <span class="string">"-20"</span>
|
||
]);
|
||
<span class="macro">assert</span><span class="macro">!</span>(<span class="ident">res</span>.<span class="ident">is_ok</span>());
|
||
<span class="kw">let</span> <span class="ident">m</span> <span class="op">=</span> <span class="ident">res</span>.<span class="ident">unwrap</span>();
|
||
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">m</span>.<span class="ident">value_of</span>(<span class="string">"num"</span>).<span class="ident">unwrap</span>(), <span class="string">"-20"</span>);</pre></div>
|
||
</div><span id="variant.AllowMissingPositional" class="variant small-section-header"><a href="#variant.AllowMissingPositional" class="anchor field"></a><code id='AllowMissingPositional.v'>AllowMissingPositional</code></span><div class='docblock'><p>Allows one to implement two styles of CLIs where positionals can be used out of order.</p>
|
||
<p>The first example is a CLI where the second to last positional argument is optional, but
|
||
the final positional argument is required. Such as <code>$ prog [optional] <required></code> where one
|
||
of the two following usages is allowed:</p>
|
||
<ul>
|
||
<li><code>$ prog [optional] <required></code></li>
|
||
<li><code>$ prog <required></code></li>
|
||
</ul>
|
||
<p>This would otherwise not be allowed. This is useful when <code>[optional]</code> has a default value.</p>
|
||
<p><strong>Note:</strong> when using this style of "missing positionals" the final positional <em>must</em> be
|
||
<a href="./struct.Arg.html#method.required">required</a> if <code>--</code> will not be used to skip to the final positional argument.</p>
|
||
<p><strong>Note:</strong> This style also only allows a single positional argument to be "skipped" without
|
||
the use of <code>--</code>. To skip more than one, see the second example.</p>
|
||
<p>The second example is when one wants to skip multiple optional positional arguments, and use
|
||
of the <code>--</code> operator is OK (but not required if all arguments will be specified anyways).</p>
|
||
<p>For example, imagine a CLI which has three positional arguments <code>[foo] [bar] [baz]...</code> where
|
||
<code>baz</code> accepts multiple values (similar to man <code>ARGS...</code> style training arguments).</p>
|
||
<p>With this setting the following invocations are possible:</p>
|
||
<ul>
|
||
<li><code>$ prog foo bar baz1 baz2 baz3</code></li>
|
||
<li><code>$ prog foo -- baz1 baz2 baz3</code></li>
|
||
<li><code>$ prog -- baz1 baz2 baz3</code></li>
|
||
</ul>
|
||
<h1 id="examples-3" class="section-header"><a href="#examples-3">Examples</a></h1>
|
||
<p>Style number one from above:</p>
|
||
|
||
<div class="example-wrap"><pre class="rust rust-example-rendered">
|
||
<span class="comment">// Assume there is an external subcommand named "subcmd"</span>
|
||
<span class="kw">let</span> <span class="ident">m</span> <span class="op">=</span> <span class="ident">App</span>::<span class="ident">new</span>(<span class="string">"myprog"</span>)
|
||
.<span class="ident">setting</span>(<span class="ident">AppSettings</span>::<span class="ident">AllowMissingPositional</span>)
|
||
.<span class="ident">arg</span>(<span class="ident">Arg</span>::<span class="ident">with_name</span>(<span class="string">"arg1"</span>))
|
||
.<span class="ident">arg</span>(<span class="ident">Arg</span>::<span class="ident">with_name</span>(<span class="string">"arg2"</span>)
|
||
.<span class="ident">required</span>(<span class="bool-val">true</span>))
|
||
.<span class="ident">get_matches_from</span>(<span class="macro">vec</span><span class="macro">!</span>[
|
||
<span class="string">"prog"</span>, <span class="string">"other"</span>
|
||
]);
|
||
|
||
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">m</span>.<span class="ident">value_of</span>(<span class="string">"arg1"</span>), <span class="prelude-val">None</span>);
|
||
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">m</span>.<span class="ident">value_of</span>(<span class="string">"arg2"</span>), <span class="prelude-val">Some</span>(<span class="string">"other"</span>));</pre></div>
|
||
<p>Now the same example, but using a default value for the first optional positional argument</p>
|
||
|
||
<div class="example-wrap"><pre class="rust rust-example-rendered">
|
||
<span class="comment">// Assume there is an external subcommand named "subcmd"</span>
|
||
<span class="kw">let</span> <span class="ident">m</span> <span class="op">=</span> <span class="ident">App</span>::<span class="ident">new</span>(<span class="string">"myprog"</span>)
|
||
.<span class="ident">setting</span>(<span class="ident">AppSettings</span>::<span class="ident">AllowMissingPositional</span>)
|
||
.<span class="ident">arg</span>(<span class="ident">Arg</span>::<span class="ident">with_name</span>(<span class="string">"arg1"</span>)
|
||
.<span class="ident">default_value</span>(<span class="string">"something"</span>))
|
||
.<span class="ident">arg</span>(<span class="ident">Arg</span>::<span class="ident">with_name</span>(<span class="string">"arg2"</span>)
|
||
.<span class="ident">required</span>(<span class="bool-val">true</span>))
|
||
.<span class="ident">get_matches_from</span>(<span class="macro">vec</span><span class="macro">!</span>[
|
||
<span class="string">"prog"</span>, <span class="string">"other"</span>
|
||
]);
|
||
|
||
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">m</span>.<span class="ident">value_of</span>(<span class="string">"arg1"</span>), <span class="prelude-val">Some</span>(<span class="string">"something"</span>));
|
||
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">m</span>.<span class="ident">value_of</span>(<span class="string">"arg2"</span>), <span class="prelude-val">Some</span>(<span class="string">"other"</span>));</pre></div>
|
||
<p>Style number two from above:</p>
|
||
|
||
<div class="example-wrap"><pre class="rust rust-example-rendered">
|
||
<span class="comment">// Assume there is an external subcommand named "subcmd"</span>
|
||
<span class="kw">let</span> <span class="ident">m</span> <span class="op">=</span> <span class="ident">App</span>::<span class="ident">new</span>(<span class="string">"myprog"</span>)
|
||
.<span class="ident">setting</span>(<span class="ident">AppSettings</span>::<span class="ident">AllowMissingPositional</span>)
|
||
.<span class="ident">arg</span>(<span class="ident">Arg</span>::<span class="ident">with_name</span>(<span class="string">"foo"</span>))
|
||
.<span class="ident">arg</span>(<span class="ident">Arg</span>::<span class="ident">with_name</span>(<span class="string">"bar"</span>))
|
||
.<span class="ident">arg</span>(<span class="ident">Arg</span>::<span class="ident">with_name</span>(<span class="string">"baz"</span>).<span class="ident">multiple</span>(<span class="bool-val">true</span>))
|
||
.<span class="ident">get_matches_from</span>(<span class="macro">vec</span><span class="macro">!</span>[
|
||
<span class="string">"prog"</span>, <span class="string">"foo"</span>, <span class="string">"bar"</span>, <span class="string">"baz1"</span>, <span class="string">"baz2"</span>, <span class="string">"baz3"</span>
|
||
]);
|
||
|
||
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">m</span>.<span class="ident">value_of</span>(<span class="string">"foo"</span>), <span class="prelude-val">Some</span>(<span class="string">"foo"</span>));
|
||
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">m</span>.<span class="ident">value_of</span>(<span class="string">"bar"</span>), <span class="prelude-val">Some</span>(<span class="string">"bar"</span>));
|
||
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">m</span>.<span class="ident">values_of</span>(<span class="string">"baz"</span>).<span class="ident">unwrap</span>().<span class="ident">collect</span>::<span class="op"><</span><span class="ident">Vec</span><span class="op"><</span><span class="kw">_</span><span class="op">></span><span class="op">></span>(), <span class="kw-2">&</span>[<span class="string">"baz1"</span>, <span class="string">"baz2"</span>, <span class="string">"baz3"</span>]);</pre></div>
|
||
<p>Now notice if we don't specify <code>foo</code> or <code>baz</code> but use the <code>--</code> operator.</p>
|
||
|
||
<div class="example-wrap"><pre class="rust rust-example-rendered">
|
||
<span class="comment">// Assume there is an external subcommand named "subcmd"</span>
|
||
<span class="kw">let</span> <span class="ident">m</span> <span class="op">=</span> <span class="ident">App</span>::<span class="ident">new</span>(<span class="string">"myprog"</span>)
|
||
.<span class="ident">setting</span>(<span class="ident">AppSettings</span>::<span class="ident">AllowMissingPositional</span>)
|
||
.<span class="ident">arg</span>(<span class="ident">Arg</span>::<span class="ident">with_name</span>(<span class="string">"foo"</span>))
|
||
.<span class="ident">arg</span>(<span class="ident">Arg</span>::<span class="ident">with_name</span>(<span class="string">"bar"</span>))
|
||
.<span class="ident">arg</span>(<span class="ident">Arg</span>::<span class="ident">with_name</span>(<span class="string">"baz"</span>).<span class="ident">multiple</span>(<span class="bool-val">true</span>))
|
||
.<span class="ident">get_matches_from</span>(<span class="macro">vec</span><span class="macro">!</span>[
|
||
<span class="string">"prog"</span>, <span class="string">"--"</span>, <span class="string">"baz1"</span>, <span class="string">"baz2"</span>, <span class="string">"baz3"</span>
|
||
]);
|
||
|
||
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">m</span>.<span class="ident">value_of</span>(<span class="string">"foo"</span>), <span class="prelude-val">None</span>);
|
||
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">m</span>.<span class="ident">value_of</span>(<span class="string">"bar"</span>), <span class="prelude-val">None</span>);
|
||
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">m</span>.<span class="ident">values_of</span>(<span class="string">"baz"</span>).<span class="ident">unwrap</span>().<span class="ident">collect</span>::<span class="op"><</span><span class="ident">Vec</span><span class="op"><</span><span class="kw">_</span><span class="op">></span><span class="op">></span>(), <span class="kw-2">&</span>[<span class="string">"baz1"</span>, <span class="string">"baz2"</span>, <span class="string">"baz3"</span>]);</pre></div>
|
||
</div><span id="variant.AllowExternalSubcommands" class="variant small-section-header"><a href="#variant.AllowExternalSubcommands" class="anchor field"></a><code id='AllowExternalSubcommands.v'>AllowExternalSubcommands</code></span><div class='docblock'><p>Specifies that an unexpected positional argument,
|
||
which would otherwise cause a <a href="./enum.ErrorKind.html#variant.UnknownArgument"><code>ErrorKind::UnknownArgument</code></a> error,
|
||
should instead be treated as a <a href="./struct.SubCommand.html"><code>SubCommand</code></a> within the <a href="./struct.ArgMatches.html"><code>ArgMatches</code></a> struct.</p>
|
||
<p><strong>NOTE:</strong> Use this setting with caution,
|
||
as a truly unexpected argument (i.e. one that is <em>NOT</em> an external subcommand)
|
||
will <strong>not</strong> cause an error and instead be treated as a potential subcommand.
|
||
One should check for such cases manually and inform the user appropriately.</p>
|
||
<h1 id="examples-4" class="section-header"><a href="#examples-4">Examples</a></h1>
|
||
<div class="example-wrap"><pre class="rust rust-example-rendered">
|
||
<span class="comment">// Assume there is an external subcommand named "subcmd"</span>
|
||
<span class="kw">let</span> <span class="ident">m</span> <span class="op">=</span> <span class="ident">App</span>::<span class="ident">new</span>(<span class="string">"myprog"</span>)
|
||
.<span class="ident">setting</span>(<span class="ident">AppSettings</span>::<span class="ident">AllowExternalSubcommands</span>)
|
||
.<span class="ident">get_matches_from</span>(<span class="macro">vec</span><span class="macro">!</span>[
|
||
<span class="string">"myprog"</span>, <span class="string">"subcmd"</span>, <span class="string">"--option"</span>, <span class="string">"value"</span>, <span class="string">"-fff"</span>, <span class="string">"--flag"</span>
|
||
]);
|
||
|
||
<span class="comment">// All trailing arguments will be stored under the subcommand's sub-matches using an empty</span>
|
||
<span class="comment">// string argument name</span>
|
||
<span class="kw">match</span> <span class="ident">m</span>.<span class="ident">subcommand</span>() {
|
||
(<span class="ident">external</span>, <span class="prelude-val">Some</span>(<span class="ident">ext_m</span>)) <span class="op">=</span><span class="op">></span> {
|
||
<span class="kw">let</span> <span class="ident">ext_args</span>: <span class="ident">Vec</span><span class="op"><</span><span class="kw-2">&</span><span class="ident">str</span><span class="op">></span> <span class="op">=</span> <span class="ident">ext_m</span>.<span class="ident">values_of</span>(<span class="string">""</span>).<span class="ident">unwrap</span>().<span class="ident">collect</span>();
|
||
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">external</span>, <span class="string">"subcmd"</span>);
|
||
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">ext_args</span>, [<span class="string">"--option"</span>, <span class="string">"value"</span>, <span class="string">"-fff"</span>, <span class="string">"--flag"</span>]);
|
||
},
|
||
<span class="kw">_</span> <span class="op">=</span><span class="op">></span> {},
|
||
}</pre></div>
|
||
</div><span id="variant.ArgsNegateSubcommands" class="variant small-section-header"><a href="#variant.ArgsNegateSubcommands" class="anchor field"></a><code id='ArgsNegateSubcommands.v'>ArgsNegateSubcommands</code></span><div class='docblock'><p>Specifies that use of a valid <a href="./struct.Arg.html">argument</a> negates <a href="./struct.SubCommand.html">subcommands</a> being used after. By default
|
||
<code>clap</code> allows arguments between subcommands such as
|
||
<code><cmd> [cmd_args] <cmd2> [cmd2_args] <cmd3> [cmd3_args]</code>. This setting disables that
|
||
functionality and says that arguments can only follow the <em>final</em> subcommand. For instance
|
||
using this setting makes only the following invocations possible:</p>
|
||
<ul>
|
||
<li><code><cmd> <cmd2> <cmd3> [cmd3_args]</code></li>
|
||
<li><code><cmd> <cmd2> [cmd2_args]</code></li>
|
||
<li><code><cmd> [cmd_args]</code></li>
|
||
</ul>
|
||
<h1 id="examples-5" class="section-header"><a href="#examples-5">Examples</a></h1>
|
||
<div class="example-wrap"><pre class="rust rust-example-rendered">
|
||
<span class="ident">App</span>::<span class="ident">new</span>(<span class="string">"myprog"</span>)
|
||
.<span class="ident">setting</span>(<span class="ident">AppSettings</span>::<span class="ident">ArgsNegateSubcommands</span>)</pre></div>
|
||
</div><span id="variant.ArgRequiredElseHelp" class="variant small-section-header"><a href="#variant.ArgRequiredElseHelp" class="anchor field"></a><code id='ArgRequiredElseHelp.v'>ArgRequiredElseHelp</code></span><div class='docblock'><p>Specifies that the help text should be displayed (and then exit gracefully),
|
||
if no arguments are present at runtime (i.e. an empty run such as, <code>$ myprog</code>.</p>
|
||
<p><strong>NOTE:</strong> <a href="./struct.SubCommand.html"><code>SubCommand</code></a>s count as arguments</p>
|
||
<p><strong>NOTE:</strong> Setting <a href="./struct.Arg.html#method.default_value"><code>Arg::default_value</code></a> effectively disables this option as it will
|
||
ensure that some argument is always present.</p>
|
||
<h1 id="examples-6" class="section-header"><a href="#examples-6">Examples</a></h1>
|
||
<div class="example-wrap"><pre class="rust rust-example-rendered">
|
||
<span class="ident">App</span>::<span class="ident">new</span>(<span class="string">"myprog"</span>)
|
||
.<span class="ident">setting</span>(<span class="ident">AppSettings</span>::<span class="ident">ArgRequiredElseHelp</span>)</pre></div>
|
||
</div><span id="variant.ColoredHelp" class="variant small-section-header"><a href="#variant.ColoredHelp" class="anchor field"></a><code id='ColoredHelp.v'>ColoredHelp</code></span><div class='docblock'><p>Uses colorized help messages.</p>
|
||
<p><strong>NOTE:</strong> Must be compiled with the <code>color</code> cargo feature</p>
|
||
<h1 id="platform-specific-1" class="section-header"><a href="#platform-specific-1">Platform Specific</a></h1>
|
||
<p>This setting only applies to Unix, Linux, and macOS (i.e. non-Windows platforms)</p>
|
||
<h1 id="examples-7" class="section-header"><a href="#examples-7">Examples</a></h1>
|
||
<div class="example-wrap"><pre class="rust rust-example-rendered">
|
||
<span class="ident">App</span>::<span class="ident">new</span>(<span class="string">"myprog"</span>)
|
||
.<span class="ident">setting</span>(<span class="ident">AppSettings</span>::<span class="ident">ColoredHelp</span>)
|
||
.<span class="ident">get_matches</span>();</pre></div>
|
||
</div><span id="variant.ColorAuto" class="variant small-section-header"><a href="#variant.ColorAuto" class="anchor field"></a><code id='ColorAuto.v'>ColorAuto</code></span><div class='docblock'><p>Enables colored output only when the output is going to a terminal or TTY.</p>
|
||
<p><strong>NOTE:</strong> This is the default behavior of <code>clap</code>.</p>
|
||
<p><strong>NOTE:</strong> Must be compiled with the <code>color</code> cargo feature.</p>
|
||
<h1 id="platform-specific-2" class="section-header"><a href="#platform-specific-2">Platform Specific</a></h1>
|
||
<p>This setting only applies to Unix, Linux, and macOS (i.e. non-Windows platforms).</p>
|
||
<h1 id="examples-8" class="section-header"><a href="#examples-8">Examples</a></h1>
|
||
<div class="example-wrap"><pre class="rust rust-example-rendered">
|
||
<span class="ident">App</span>::<span class="ident">new</span>(<span class="string">"myprog"</span>)
|
||
.<span class="ident">setting</span>(<span class="ident">AppSettings</span>::<span class="ident">ColorAuto</span>)
|
||
.<span class="ident">get_matches</span>();</pre></div>
|
||
</div><span id="variant.ColorAlways" class="variant small-section-header"><a href="#variant.ColorAlways" class="anchor field"></a><code id='ColorAlways.v'>ColorAlways</code></span><div class='docblock'><p>Enables colored output regardless of whether or not the output is going to a terminal/TTY.</p>
|
||
<p><strong>NOTE:</strong> Must be compiled with the <code>color</code> cargo feature.</p>
|
||
<h1 id="platform-specific-3" class="section-header"><a href="#platform-specific-3">Platform Specific</a></h1>
|
||
<p>This setting only applies to Unix, Linux, and macOS (i.e. non-Windows platforms).</p>
|
||
<h1 id="examples-9" class="section-header"><a href="#examples-9">Examples</a></h1>
|
||
<div class="example-wrap"><pre class="rust rust-example-rendered">
|
||
<span class="ident">App</span>::<span class="ident">new</span>(<span class="string">"myprog"</span>)
|
||
.<span class="ident">setting</span>(<span class="ident">AppSettings</span>::<span class="ident">ColorAlways</span>)
|
||
.<span class="ident">get_matches</span>();</pre></div>
|
||
</div><span id="variant.ColorNever" class="variant small-section-header"><a href="#variant.ColorNever" class="anchor field"></a><code id='ColorNever.v'>ColorNever</code></span><div class='docblock'><p>Disables colored output no matter if the output is going to a terminal/TTY, or not.</p>
|
||
<p><strong>NOTE:</strong> Must be compiled with the <code>color</code> cargo feature</p>
|
||
<h1 id="platform-specific-4" class="section-header"><a href="#platform-specific-4">Platform Specific</a></h1>
|
||
<p>This setting only applies to Unix, Linux, and macOS (i.e. non-Windows platforms)</p>
|
||
<h1 id="examples-10" class="section-header"><a href="#examples-10">Examples</a></h1>
|
||
<div class="example-wrap"><pre class="rust rust-example-rendered">
|
||
<span class="ident">App</span>::<span class="ident">new</span>(<span class="string">"myprog"</span>)
|
||
.<span class="ident">setting</span>(<span class="ident">AppSettings</span>::<span class="ident">ColorNever</span>)
|
||
.<span class="ident">get_matches</span>();</pre></div>
|
||
</div><span id="variant.DontCollapseArgsInUsage" class="variant small-section-header"><a href="#variant.DontCollapseArgsInUsage" class="anchor field"></a><code id='DontCollapseArgsInUsage.v'>DontCollapseArgsInUsage</code></span><div class='docblock'><p>Disables the automatic collapsing of positional args into <code>[ARGS]</code> inside the usage string</p>
|
||
<h1 id="examples-11" class="section-header"><a href="#examples-11">Examples</a></h1>
|
||
<div class="example-wrap"><pre class="rust rust-example-rendered">
|
||
<span class="ident">App</span>::<span class="ident">new</span>(<span class="string">"myprog"</span>)
|
||
.<span class="ident">setting</span>(<span class="ident">AppSettings</span>::<span class="ident">DontCollapseArgsInUsage</span>)
|
||
.<span class="ident">get_matches</span>();</pre></div>
|
||
</div><span id="variant.DontDelimitTrailingValues" class="variant small-section-header"><a href="#variant.DontDelimitTrailingValues" class="anchor field"></a><code id='DontDelimitTrailingValues.v'>DontDelimitTrailingValues</code></span><div class='docblock'><p>Disables the automatic delimiting of values when <code>--</code> or <a href="./enum.AppSettings.html#variant.TrailingVarArg"><code>AppSettings::TrailingVarArg</code></a>
|
||
was used.</p>
|
||
<p><strong>NOTE:</strong> The same thing can be done manually by setting the final positional argument to
|
||
<a href="./struct.Arg.html#method.use_delimiter"><code>Arg::use_delimiter(false)</code></a>. Using this setting is safer, because it's easier to locate
|
||
when making changes.</p>
|
||
<h1 id="examples-12" class="section-header"><a href="#examples-12">Examples</a></h1>
|
||
<div class="example-wrap"><pre class="rust rust-example-rendered">
|
||
<span class="ident">App</span>::<span class="ident">new</span>(<span class="string">"myprog"</span>)
|
||
.<span class="ident">setting</span>(<span class="ident">AppSettings</span>::<span class="ident">DontDelimitTrailingValues</span>)
|
||
.<span class="ident">get_matches</span>();</pre></div>
|
||
</div><span id="variant.DisableHelpFlags" class="variant small-section-header"><a href="#variant.DisableHelpFlags" class="anchor field"></a><code id='DisableHelpFlags.v'>DisableHelpFlags</code></span><div class='docblock'><p>Disables <code>-h</code> and <code>--help</code> <a href="./struct.App.html"><code>App</code></a> without affecting any of the <a href="./struct.SubCommand.html"><code>SubCommand</code></a>s
|
||
(Defaults to <code>false</code>; application <em>does</em> have help flags)</p>
|
||
<h1 id="examples-13" class="section-header"><a href="#examples-13">Examples</a></h1>
|
||
<div class="example-wrap"><pre class="rust rust-example-rendered">
|
||
<span class="kw">let</span> <span class="ident">res</span> <span class="op">=</span> <span class="ident">App</span>::<span class="ident">new</span>(<span class="string">"myprog"</span>)
|
||
.<span class="ident">setting</span>(<span class="ident">AppSettings</span>::<span class="ident">DisableHelpFlags</span>)
|
||
.<span class="ident">get_matches_from_safe</span>(<span class="macro">vec</span><span class="macro">!</span>[
|
||
<span class="string">"myprog"</span>, <span class="string">"-h"</span>
|
||
]);
|
||
<span class="macro">assert</span><span class="macro">!</span>(<span class="ident">res</span>.<span class="ident">is_err</span>());
|
||
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">res</span>.<span class="ident">unwrap_err</span>().<span class="ident">kind</span>, <span class="ident">ErrorKind</span>::<span class="ident">UnknownArgument</span>);</pre></div>
|
||
|
||
<div class="example-wrap"><pre class="rust rust-example-rendered">
|
||
<span class="kw">let</span> <span class="ident">res</span> <span class="op">=</span> <span class="ident">App</span>::<span class="ident">new</span>(<span class="string">"myprog"</span>)
|
||
.<span class="ident">setting</span>(<span class="ident">AppSettings</span>::<span class="ident">DisableHelpFlags</span>)
|
||
.<span class="ident">subcommand</span>(<span class="ident">SubCommand</span>::<span class="ident">with_name</span>(<span class="string">"test"</span>))
|
||
.<span class="ident">get_matches_from_safe</span>(<span class="macro">vec</span><span class="macro">!</span>[
|
||
<span class="string">"myprog"</span>, <span class="string">"test"</span>, <span class="string">"-h"</span>
|
||
]);
|
||
<span class="macro">assert</span><span class="macro">!</span>(<span class="ident">res</span>.<span class="ident">is_err</span>());
|
||
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">res</span>.<span class="ident">unwrap_err</span>().<span class="ident">kind</span>, <span class="ident">ErrorKind</span>::<span class="ident">HelpDisplayed</span>);</pre></div>
|
||
</div><span id="variant.DisableHelpSubcommand" class="variant small-section-header"><a href="#variant.DisableHelpSubcommand" class="anchor field"></a><code id='DisableHelpSubcommand.v'>DisableHelpSubcommand</code></span><div class='docblock'><p>Disables the <code>help</code> subcommand</p>
|
||
<h1 id="examples-14" class="section-header"><a href="#examples-14">Examples</a></h1>
|
||
<div class="example-wrap"><pre class="rust rust-example-rendered">
|
||
<span class="kw">let</span> <span class="ident">res</span> <span class="op">=</span> <span class="ident">App</span>::<span class="ident">new</span>(<span class="string">"myprog"</span>)
|
||
.<span class="ident">version</span>(<span class="string">"v1.1"</span>)
|
||
.<span class="ident">setting</span>(<span class="ident">AppSettings</span>::<span class="ident">DisableHelpSubcommand</span>)
|
||
<span class="comment">// Normally, creating a subcommand causes a `help` subcommand to automatically</span>
|
||
<span class="comment">// be generated as well</span>
|
||
.<span class="ident">subcommand</span>(<span class="ident">SubCommand</span>::<span class="ident">with_name</span>(<span class="string">"test"</span>))
|
||
.<span class="ident">get_matches_from_safe</span>(<span class="macro">vec</span><span class="macro">!</span>[
|
||
<span class="string">"myprog"</span>, <span class="string">"help"</span>
|
||
]);
|
||
<span class="macro">assert</span><span class="macro">!</span>(<span class="ident">res</span>.<span class="ident">is_err</span>());
|
||
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">res</span>.<span class="ident">unwrap_err</span>().<span class="ident">kind</span>, <span class="ident">ErrorKind</span>::<span class="ident">UnknownArgument</span>);</pre></div>
|
||
</div><span id="variant.DisableVersion" class="variant small-section-header"><a href="#variant.DisableVersion" class="anchor field"></a><code id='DisableVersion.v'>DisableVersion</code></span><div class='docblock'><p>Disables <code>-V</code> and <code>--version</code> <a href="./struct.App.html"><code>App</code></a> without affecting any of the <a href="./struct.SubCommand.html"><code>SubCommand</code></a>s
|
||
(Defaults to <code>false</code>; application <em>does</em> have a version flag)</p>
|
||
<h1 id="examples-15" class="section-header"><a href="#examples-15">Examples</a></h1>
|
||
<div class="example-wrap"><pre class="rust rust-example-rendered">
|
||
<span class="kw">let</span> <span class="ident">res</span> <span class="op">=</span> <span class="ident">App</span>::<span class="ident">new</span>(<span class="string">"myprog"</span>)
|
||
.<span class="ident">version</span>(<span class="string">"v1.1"</span>)
|
||
.<span class="ident">setting</span>(<span class="ident">AppSettings</span>::<span class="ident">DisableVersion</span>)
|
||
.<span class="ident">get_matches_from_safe</span>(<span class="macro">vec</span><span class="macro">!</span>[
|
||
<span class="string">"myprog"</span>, <span class="string">"-V"</span>
|
||
]);
|
||
<span class="macro">assert</span><span class="macro">!</span>(<span class="ident">res</span>.<span class="ident">is_err</span>());
|
||
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">res</span>.<span class="ident">unwrap_err</span>().<span class="ident">kind</span>, <span class="ident">ErrorKind</span>::<span class="ident">UnknownArgument</span>);</pre></div>
|
||
|
||
<div class="example-wrap"><pre class="rust rust-example-rendered">
|
||
<span class="kw">let</span> <span class="ident">res</span> <span class="op">=</span> <span class="ident">App</span>::<span class="ident">new</span>(<span class="string">"myprog"</span>)
|
||
.<span class="ident">version</span>(<span class="string">"v1.1"</span>)
|
||
.<span class="ident">setting</span>(<span class="ident">AppSettings</span>::<span class="ident">DisableVersion</span>)
|
||
.<span class="ident">subcommand</span>(<span class="ident">SubCommand</span>::<span class="ident">with_name</span>(<span class="string">"test"</span>))
|
||
.<span class="ident">get_matches_from_safe</span>(<span class="macro">vec</span><span class="macro">!</span>[
|
||
<span class="string">"myprog"</span>, <span class="string">"test"</span>, <span class="string">"-V"</span>
|
||
]);
|
||
<span class="macro">assert</span><span class="macro">!</span>(<span class="ident">res</span>.<span class="ident">is_err</span>());
|
||
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">res</span>.<span class="ident">unwrap_err</span>().<span class="ident">kind</span>, <span class="ident">ErrorKind</span>::<span class="ident">VersionDisplayed</span>);</pre></div>
|
||
</div><span id="variant.DeriveDisplayOrder" class="variant small-section-header"><a href="#variant.DeriveDisplayOrder" class="anchor field"></a><code id='DeriveDisplayOrder.v'>DeriveDisplayOrder</code></span><div class='docblock'><p>Displays the arguments and <a href="./struct.SubCommand.html"><code>SubCommand</code></a>s in the help message in the order that they were
|
||
declared in, and not alphabetically which is the default.</p>
|
||
<h1 id="examples-16" class="section-header"><a href="#examples-16">Examples</a></h1>
|
||
<div class="example-wrap"><pre class="rust rust-example-rendered">
|
||
<span class="ident">App</span>::<span class="ident">new</span>(<span class="string">"myprog"</span>)
|
||
.<span class="ident">setting</span>(<span class="ident">AppSettings</span>::<span class="ident">DeriveDisplayOrder</span>)
|
||
.<span class="ident">get_matches</span>();</pre></div>
|
||
</div><span id="variant.GlobalVersion" class="variant small-section-header"><a href="#variant.GlobalVersion" class="anchor field"></a><code id='GlobalVersion.v'>GlobalVersion</code></span><div class='docblock'><p>Specifies to use the version of the current command for all child <a href="./struct.SubCommand.html"><code>SubCommand</code></a>s.
|
||
(Defaults to <code>false</code>; subcommands have independent version strings from their parents.)</p>
|
||
<p><strong>NOTE:</strong> The version for the current command <strong>and</strong> this setting must be set <strong>prior</strong> to
|
||
adding any child subcommands</p>
|
||
<h1 id="examples-17" class="section-header"><a href="#examples-17">Examples</a></h1>
|
||
<div class="example-wrap"><pre class="rust rust-example-rendered">
|
||
<span class="ident">App</span>::<span class="ident">new</span>(<span class="string">"myprog"</span>)
|
||
.<span class="ident">version</span>(<span class="string">"v1.1"</span>)
|
||
.<span class="ident">setting</span>(<span class="ident">AppSettings</span>::<span class="ident">GlobalVersion</span>)
|
||
.<span class="ident">subcommand</span>(<span class="ident">SubCommand</span>::<span class="ident">with_name</span>(<span class="string">"test"</span>))
|
||
.<span class="ident">get_matches</span>();
|
||
<span class="comment">// running `$ myprog test --version` will display</span>
|
||
<span class="comment">// "myprog-test v1.1"</span></pre></div>
|
||
</div><span id="variant.Hidden" class="variant small-section-header"><a href="#variant.Hidden" class="anchor field"></a><code id='Hidden.v'>Hidden</code></span><div class='docblock'><p>Specifies that this <a href="./struct.SubCommand.html"><code>SubCommand</code></a> should be hidden from help messages</p>
|
||
<h1 id="examples-18" class="section-header"><a href="#examples-18">Examples</a></h1>
|
||
<div class="example-wrap"><pre class="rust rust-example-rendered">
|
||
<span class="ident">App</span>::<span class="ident">new</span>(<span class="string">"myprog"</span>)
|
||
.<span class="ident">subcommand</span>(<span class="ident">SubCommand</span>::<span class="ident">with_name</span>(<span class="string">"test"</span>)
|
||
.<span class="ident">setting</span>(<span class="ident">AppSettings</span>::<span class="ident">Hidden</span>))</pre></div>
|
||
</div><span id="variant.HidePossibleValuesInHelp" class="variant small-section-header"><a href="#variant.HidePossibleValuesInHelp" class="anchor field"></a><code id='HidePossibleValuesInHelp.v'>HidePossibleValuesInHelp</code></span><div class='docblock'><p>Tells <code>clap</code> <em>not</em> to print possible values when displaying help information.
|
||
This can be useful if there are many values, or they are explained elsewhere.</p>
|
||
</div><span id="variant.InferSubcommands" class="variant small-section-header"><a href="#variant.InferSubcommands" class="anchor field"></a><code id='InferSubcommands.v'>InferSubcommands</code></span><div class='docblock'><p>Tries to match unknown args to partial <a href="./struct.SubCommand.html"><code>subcommands</code></a> or their <a href="./struct.App.html#method.alias">aliases</a>. For example to
|
||
match a subcommand named <code>test</code>, one could use <code>t</code>, <code>te</code>, <code>tes</code>, and <code>test</code>.</p>
|
||
<p><strong>NOTE:</strong> The match <em>must not</em> be ambiguous at all in order to succeed. i.e. to match <code>te</code>
|
||
to <code>test</code> there could not also be a subcommand or alias <code>temp</code> because both start with <code>te</code></p>
|
||
<p><strong>CAUTION:</strong> This setting can interfere with <a href="./struct.Arg.html#method.index">positional/free arguments</a>, take care when
|
||
designing CLIs which allow inferred subcommands and have potential positional/free
|
||
arguments whose values could start with the same characters as subcommands. If this is the
|
||
case, it's recommended to use settings such as <a href="./enum.AppSettings.html#variant.ArgsNegateSubcommands"><code>AppSeettings::ArgsNegateSubcommands</code></a> in
|
||
conjunction with this setting.</p>
|
||
<h1 id="examples-19" class="section-header"><a href="#examples-19">Examples</a></h1>
|
||
<div class="example-wrap"><pre class="rust rust-example-rendered">
|
||
<span class="kw">let</span> <span class="ident">m</span> <span class="op">=</span> <span class="ident">App</span>::<span class="ident">new</span>(<span class="string">"prog"</span>)
|
||
.<span class="ident">setting</span>(<span class="ident">AppSettings</span>::<span class="ident">InferSubcommands</span>)
|
||
.<span class="ident">subcommand</span>(<span class="ident">SubCommand</span>::<span class="ident">with_name</span>(<span class="string">"test"</span>))
|
||
.<span class="ident">get_matches_from</span>(<span class="macro">vec</span><span class="macro">!</span>[
|
||
<span class="string">"prog"</span>, <span class="string">"te"</span>
|
||
]);
|
||
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">m</span>.<span class="ident">subcommand_name</span>(), <span class="prelude-val">Some</span>(<span class="string">"test"</span>));</pre></div>
|
||
</div><span id="variant.NoBinaryName" class="variant small-section-header"><a href="#variant.NoBinaryName" class="anchor field"></a><code id='NoBinaryName.v'>NoBinaryName</code></span><div class='docblock'><p>Specifies that the parser should not assume the first argument passed is the binary name.
|
||
This is normally the case when using a "daemon" style mode, or an interactive CLI where one
|
||
one would not normally type the binary or program name for each command.</p>
|
||
<h1 id="examples-20" class="section-header"><a href="#examples-20">Examples</a></h1>
|
||
<div class="example-wrap"><pre class="rust rust-example-rendered">
|
||
<span class="kw">let</span> <span class="ident">m</span> <span class="op">=</span> <span class="ident">App</span>::<span class="ident">new</span>(<span class="string">"myprog"</span>)
|
||
.<span class="ident">setting</span>(<span class="ident">AppSettings</span>::<span class="ident">NoBinaryName</span>)
|
||
.<span class="ident">arg</span>(<span class="ident">Arg</span>::<span class="ident">from_usage</span>(<span class="string">"<cmd>... 'commands to run'"</span>))
|
||
.<span class="ident">get_matches_from</span>(<span class="macro">vec</span><span class="macro">!</span>[<span class="string">"command"</span>, <span class="string">"set"</span>]);
|
||
|
||
<span class="kw">let</span> <span class="ident">cmds</span>: <span class="ident">Vec</span><span class="op"><</span><span class="kw-2">&</span><span class="ident">str</span><span class="op">></span> <span class="op">=</span> <span class="ident">m</span>.<span class="ident">values_of</span>(<span class="string">"cmd"</span>).<span class="ident">unwrap</span>().<span class="ident">collect</span>();
|
||
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">cmds</span>, [<span class="string">"command"</span>, <span class="string">"set"</span>]);</pre></div>
|
||
</div><span id="variant.NextLineHelp" class="variant small-section-header"><a href="#variant.NextLineHelp" class="anchor field"></a><code id='NextLineHelp.v'>NextLineHelp</code></span><div class='docblock'><p>Places the help string for all arguments on the line after the argument.</p>
|
||
<h1 id="examples-21" class="section-header"><a href="#examples-21">Examples</a></h1>
|
||
<div class="example-wrap"><pre class="rust rust-example-rendered">
|
||
<span class="ident">App</span>::<span class="ident">new</span>(<span class="string">"myprog"</span>)
|
||
.<span class="ident">setting</span>(<span class="ident">AppSettings</span>::<span class="ident">NextLineHelp</span>)
|
||
.<span class="ident">get_matches</span>();</pre></div>
|
||
</div><span id="variant.PropagateGlobalValuesDown" class="variant small-section-header"><a href="#variant.PropagateGlobalValuesDown" class="anchor field"></a><code id='PropagateGlobalValuesDown.v'>PropagateGlobalValuesDown</code></span><div class='stability'><div class='stab deprecated'>Deprecated since 2.27.0: <p>No longer required to propagate values</p>
|
||
</div></div><div class='docblock'><p><strong>DEPRECATED</strong>: This setting is no longer required in order to propagate values up or down</p>
|
||
<p>Specifies that the parser should propagate global arg's values down or up through any <em>used</em>
|
||
child subcommands. Meaning, if a subcommand wasn't used, the values won't be propagated to
|
||
said subcommand.</p>
|
||
<h1 id="examples-22" class="section-header"><a href="#examples-22">Examples</a></h1>
|
||
<div class="example-wrap"><pre class="rust rust-example-rendered">
|
||
<span class="kw">let</span> <span class="ident">m</span> <span class="op">=</span> <span class="ident">App</span>::<span class="ident">new</span>(<span class="string">"myprog"</span>)
|
||
.<span class="ident">arg</span>(<span class="ident">Arg</span>::<span class="ident">from_usage</span>(<span class="string">"[cmd] 'command to run'"</span>)
|
||
.<span class="ident">global</span>(<span class="bool-val">true</span>))
|
||
.<span class="ident">subcommand</span>(<span class="ident">SubCommand</span>::<span class="ident">with_name</span>(<span class="string">"foo"</span>))
|
||
.<span class="ident">get_matches_from</span>(<span class="macro">vec</span><span class="macro">!</span>[<span class="string">"myprog"</span>, <span class="string">"set"</span>, <span class="string">"foo"</span>]);
|
||
|
||
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">m</span>.<span class="ident">value_of</span>(<span class="string">"cmd"</span>), <span class="prelude-val">Some</span>(<span class="string">"set"</span>));
|
||
|
||
<span class="kw">let</span> <span class="ident">sub_m</span> <span class="op">=</span> <span class="ident">m</span>.<span class="ident">subcommand_matches</span>(<span class="string">"foo"</span>).<span class="ident">unwrap</span>();
|
||
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">sub_m</span>.<span class="ident">value_of</span>(<span class="string">"cmd"</span>), <span class="prelude-val">Some</span>(<span class="string">"set"</span>));</pre></div>
|
||
<p>Now doing the same thing, but <em>not</em> using any subcommands will result in the value not being
|
||
propagated down.</p>
|
||
|
||
<div class="example-wrap"><pre class="rust rust-example-rendered">
|
||
<span class="kw">let</span> <span class="ident">m</span> <span class="op">=</span> <span class="ident">App</span>::<span class="ident">new</span>(<span class="string">"myprog"</span>)
|
||
.<span class="ident">arg</span>(<span class="ident">Arg</span>::<span class="ident">from_usage</span>(<span class="string">"[cmd] 'command to run'"</span>)
|
||
.<span class="ident">global</span>(<span class="bool-val">true</span>))
|
||
.<span class="ident">subcommand</span>(<span class="ident">SubCommand</span>::<span class="ident">with_name</span>(<span class="string">"foo"</span>))
|
||
.<span class="ident">get_matches_from</span>(<span class="macro">vec</span><span class="macro">!</span>[<span class="string">"myprog"</span>, <span class="string">"set"</span>]);
|
||
|
||
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">m</span>.<span class="ident">value_of</span>(<span class="string">"cmd"</span>), <span class="prelude-val">Some</span>(<span class="string">"set"</span>));
|
||
|
||
<span class="macro">assert</span><span class="macro">!</span>(<span class="ident">m</span>.<span class="ident">subcommand_matches</span>(<span class="string">"foo"</span>).<span class="ident">is_none</span>());</pre></div>
|
||
</div><span id="variant.SubcommandsNegateReqs" class="variant small-section-header"><a href="#variant.SubcommandsNegateReqs" class="anchor field"></a><code id='SubcommandsNegateReqs.v'>SubcommandsNegateReqs</code></span><div class='docblock'><p>Allows <a href="./struct.SubCommand.html"><code>SubCommand</code></a>s to override all requirements of the parent command.
|
||
For example if you had a subcommand or top level application with a required argument
|
||
that is only required as long as there is no subcommand present,
|
||
using this setting would allow you to set those arguments to <a href="./struct.Arg.html#method.required"><code>Arg::required(true)</code></a>
|
||
and yet receive no error so long as the user uses a valid subcommand instead.</p>
|
||
<p><strong>NOTE:</strong> This defaults to false (using subcommand does <em>not</em> negate requirements)</p>
|
||
<h1 id="examples-23" class="section-header"><a href="#examples-23">Examples</a></h1>
|
||
<p>This first example shows that it is an error to not use a required argument</p>
|
||
|
||
<div class="example-wrap"><pre class="rust rust-example-rendered">
|
||
<span class="kw">let</span> <span class="ident">err</span> <span class="op">=</span> <span class="ident">App</span>::<span class="ident">new</span>(<span class="string">"myprog"</span>)
|
||
.<span class="ident">setting</span>(<span class="ident">AppSettings</span>::<span class="ident">SubcommandsNegateReqs</span>)
|
||
.<span class="ident">arg</span>(<span class="ident">Arg</span>::<span class="ident">with_name</span>(<span class="string">"opt"</span>).<span class="ident">required</span>(<span class="bool-val">true</span>))
|
||
.<span class="ident">subcommand</span>(<span class="ident">SubCommand</span>::<span class="ident">with_name</span>(<span class="string">"test"</span>))
|
||
.<span class="ident">get_matches_from_safe</span>(<span class="macro">vec</span><span class="macro">!</span>[
|
||
<span class="string">"myprog"</span>
|
||
]);
|
||
<span class="macro">assert</span><span class="macro">!</span>(<span class="ident">err</span>.<span class="ident">is_err</span>());
|
||
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">err</span>.<span class="ident">unwrap_err</span>().<span class="ident">kind</span>, <span class="ident">ErrorKind</span>::<span class="ident">MissingRequiredArgument</span>);</pre></div>
|
||
<p>This next example shows that it is no longer error to not use a required argument if a
|
||
valid subcommand is used.</p>
|
||
|
||
<div class="example-wrap"><pre class="rust rust-example-rendered">
|
||
<span class="kw">let</span> <span class="ident">noerr</span> <span class="op">=</span> <span class="ident">App</span>::<span class="ident">new</span>(<span class="string">"myprog"</span>)
|
||
.<span class="ident">setting</span>(<span class="ident">AppSettings</span>::<span class="ident">SubcommandsNegateReqs</span>)
|
||
.<span class="ident">arg</span>(<span class="ident">Arg</span>::<span class="ident">with_name</span>(<span class="string">"opt"</span>).<span class="ident">required</span>(<span class="bool-val">true</span>))
|
||
.<span class="ident">subcommand</span>(<span class="ident">SubCommand</span>::<span class="ident">with_name</span>(<span class="string">"test"</span>))
|
||
.<span class="ident">get_matches_from_safe</span>(<span class="macro">vec</span><span class="macro">!</span>[
|
||
<span class="string">"myprog"</span>, <span class="string">"test"</span>
|
||
]);
|
||
<span class="macro">assert</span><span class="macro">!</span>(<span class="ident">noerr</span>.<span class="ident">is_ok</span>());</pre></div>
|
||
</div><span id="variant.SubcommandRequiredElseHelp" class="variant small-section-header"><a href="#variant.SubcommandRequiredElseHelp" class="anchor field"></a><code id='SubcommandRequiredElseHelp.v'>SubcommandRequiredElseHelp</code></span><div class='docblock'><p>Specifies that the help text should be displayed (before exiting gracefully) if no
|
||
<a href="./struct.SubCommand.html"><code>SubCommand</code></a>s are present at runtime (i.e. an empty run such as <code>$ myprog</code>).</p>
|
||
<p><strong>NOTE:</strong> This should <em>not</em> be used with <a href="./enum.AppSettings.html#variant.SubcommandRequired"><code>AppSettings::SubcommandRequired</code></a> as they do
|
||
nearly same thing; this prints the help text, and the other prints an error.</p>
|
||
<p><strong>NOTE:</strong> If the user specifies arguments at runtime, but no subcommand the help text will
|
||
still be displayed and exit. If this is <em>not</em> the desired result, consider using
|
||
<a href="./enum.AppSettings.html#variant.ArgRequiredElseHelp"><code>AppSettings::ArgRequiredElseHelp</code></a> instead.</p>
|
||
<h1 id="examples-24" class="section-header"><a href="#examples-24">Examples</a></h1>
|
||
<div class="example-wrap"><pre class="rust rust-example-rendered">
|
||
<span class="ident">App</span>::<span class="ident">new</span>(<span class="string">"myprog"</span>)
|
||
.<span class="ident">setting</span>(<span class="ident">AppSettings</span>::<span class="ident">SubcommandRequiredElseHelp</span>)</pre></div>
|
||
</div><span id="variant.StrictUtf8" class="variant small-section-header"><a href="#variant.StrictUtf8" class="anchor field"></a><code id='StrictUtf8.v'>StrictUtf8</code></span><div class='docblock'><p>Specifies that any invalid UTF-8 code points should be treated as an error and fail
|
||
with a <a href="./enum.ErrorKind.html#variant.InvalidUtf8"><code>ErrorKind::InvalidUtf8</code></a> error.</p>
|
||
<p><strong>NOTE:</strong> This rule only applies to argument values; Things such as flags, options, and
|
||
<a href="./struct.SubCommand.html"><code>SubCommand</code></a>s themselves only allow valid UTF-8 code points.</p>
|
||
<h1 id="platform-specific-5" class="section-header"><a href="#platform-specific-5">Platform Specific</a></h1>
|
||
<p>Non Windows systems only</p>
|
||
<h1 id="examples-25" class="section-header"><a href="#examples-25">Examples</a></h1>
|
||
<div class="example-wrap"><pre class="rust rust-example-rendered">
|
||
<span class="kw">use</span> <span class="ident">std</span>::<span class="ident">ffi</span>::<span class="ident">OsString</span>;
|
||
<span class="kw">use</span> <span class="ident">std</span>::<span class="ident">os</span>::<span class="ident">unix</span>::<span class="ident">ffi</span>::<span class="ident">OsStringExt</span>;
|
||
|
||
<span class="kw">let</span> <span class="ident">m</span> <span class="op">=</span> <span class="ident">App</span>::<span class="ident">new</span>(<span class="string">"myprog"</span>)
|
||
.<span class="ident">setting</span>(<span class="ident">AppSettings</span>::<span class="ident">StrictUtf8</span>)
|
||
.<span class="ident">arg_from_usage</span>(<span class="string">"<arg> 'some positional arg'"</span>)
|
||
.<span class="ident">get_matches_from_safe</span>(
|
||
<span class="macro">vec</span><span class="macro">!</span>[
|
||
<span class="ident">OsString</span>::<span class="ident">from</span>(<span class="string">"myprog"</span>),
|
||
<span class="ident">OsString</span>::<span class="ident">from_vec</span>(<span class="macro">vec</span><span class="macro">!</span>[<span class="number">0xe9</span>])]);
|
||
|
||
<span class="macro">assert</span><span class="macro">!</span>(<span class="ident">m</span>.<span class="ident">is_err</span>());
|
||
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">m</span>.<span class="ident">unwrap_err</span>().<span class="ident">kind</span>, <span class="ident">ErrorKind</span>::<span class="ident">InvalidUtf8</span>);</pre></div>
|
||
</div><span id="variant.SubcommandRequired" class="variant small-section-header"><a href="#variant.SubcommandRequired" class="anchor field"></a><code id='SubcommandRequired.v'>SubcommandRequired</code></span><div class='docblock'><p>Allows specifying that if no <a href="./struct.SubCommand.html"><code>SubCommand</code></a> is present at runtime,
|
||
error and exit gracefully.</p>
|
||
<p><strong>NOTE:</strong> This defaults to <code>false</code> (subcommands do <em>not</em> need to be present)</p>
|
||
<h1 id="examples-26" class="section-header"><a href="#examples-26">Examples</a></h1>
|
||
<div class="example-wrap"><pre class="rust rust-example-rendered">
|
||
<span class="kw">let</span> <span class="ident">err</span> <span class="op">=</span> <span class="ident">App</span>::<span class="ident">new</span>(<span class="string">"myprog"</span>)
|
||
.<span class="ident">setting</span>(<span class="ident">AppSettings</span>::<span class="ident">SubcommandRequired</span>)
|
||
.<span class="ident">subcommand</span>(<span class="ident">SubCommand</span>::<span class="ident">with_name</span>(<span class="string">"test"</span>))
|
||
.<span class="ident">get_matches_from_safe</span>(<span class="macro">vec</span><span class="macro">!</span>[
|
||
<span class="string">"myprog"</span>,
|
||
]);
|
||
<span class="macro">assert</span><span class="macro">!</span>(<span class="ident">err</span>.<span class="ident">is_err</span>());
|
||
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">err</span>.<span class="ident">unwrap_err</span>().<span class="ident">kind</span>, <span class="ident">ErrorKind</span>::<span class="ident">MissingSubcommand</span>);</pre></div>
|
||
</div><span id="variant.TrailingVarArg" class="variant small-section-header"><a href="#variant.TrailingVarArg" class="anchor field"></a><code id='TrailingVarArg.v'>TrailingVarArg</code></span><div class='docblock'><p>Specifies that the final positional argument is a "VarArg" and that <code>clap</code> should not
|
||
attempt to parse any further args.</p>
|
||
<p>The values of the trailing positional argument will contain all args from itself on.</p>
|
||
<p><strong>NOTE:</strong> The final positional argument <strong>must</strong> have <a href="./struct.Arg.html#method.multiple"><code>Arg::multiple(true)</code></a> or the usage
|
||
string equivalent.</p>
|
||
<h1 id="examples-27" class="section-header"><a href="#examples-27">Examples</a></h1>
|
||
<div class="example-wrap"><pre class="rust rust-example-rendered">
|
||
<span class="kw">let</span> <span class="ident">m</span> <span class="op">=</span> <span class="ident">App</span>::<span class="ident">new</span>(<span class="string">"myprog"</span>)
|
||
.<span class="ident">setting</span>(<span class="ident">AppSettings</span>::<span class="ident">TrailingVarArg</span>)
|
||
.<span class="ident">arg</span>(<span class="ident">Arg</span>::<span class="ident">from_usage</span>(<span class="string">"<cmd>... 'commands to run'"</span>))
|
||
.<span class="ident">get_matches_from</span>(<span class="macro">vec</span><span class="macro">!</span>[<span class="string">"myprog"</span>, <span class="string">"arg1"</span>, <span class="string">"-r"</span>, <span class="string">"val1"</span>]);
|
||
|
||
<span class="kw">let</span> <span class="ident">trail</span>: <span class="ident">Vec</span><span class="op"><</span><span class="kw-2">&</span><span class="ident">str</span><span class="op">></span> <span class="op">=</span> <span class="ident">m</span>.<span class="ident">values_of</span>(<span class="string">"cmd"</span>).<span class="ident">unwrap</span>().<span class="ident">collect</span>();
|
||
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">trail</span>, [<span class="string">"arg1"</span>, <span class="string">"-r"</span>, <span class="string">"val1"</span>]);</pre></div>
|
||
</div><span id="variant.UnifiedHelpMessage" class="variant small-section-header"><a href="#variant.UnifiedHelpMessage" class="anchor field"></a><code id='UnifiedHelpMessage.v'>UnifiedHelpMessage</code></span><div class='docblock'><p>Groups flags and options together, presenting a more unified help message
|
||
(a la <code>getopts</code> or <code>docopt</code> style).</p>
|
||
<p>The default is that the auto-generated help message will group flags, and options
|
||
separately.</p>
|
||
<p><strong>NOTE:</strong> This setting is cosmetic only and does not affect any functionality.</p>
|
||
<h1 id="examples-28" class="section-header"><a href="#examples-28">Examples</a></h1>
|
||
<div class="example-wrap"><pre class="rust rust-example-rendered">
|
||
<span class="ident">App</span>::<span class="ident">new</span>(<span class="string">"myprog"</span>)
|
||
.<span class="ident">setting</span>(<span class="ident">AppSettings</span>::<span class="ident">UnifiedHelpMessage</span>)
|
||
.<span class="ident">get_matches</span>();
|
||
<span class="comment">// running `myprog --help` will display a unified "docopt" or "getopts" style help message</span></pre></div>
|
||
</div><span id="variant.VersionlessSubcommands" class="variant small-section-header"><a href="#variant.VersionlessSubcommands" class="anchor field"></a><code id='VersionlessSubcommands.v'>VersionlessSubcommands</code></span><div class='docblock'><p>Disables <code>-V</code> and <code>--version</code> for all <a href="./struct.SubCommand.html"><code>SubCommand</code></a>s
|
||
(Defaults to <code>false</code>; subcommands <em>do</em> have version flags.)</p>
|
||
<p><strong>NOTE:</strong> This setting must be set <strong>prior</strong> to adding any subcommands.</p>
|
||
<h1 id="examples-29" class="section-header"><a href="#examples-29">Examples</a></h1>
|
||
<div class="example-wrap"><pre class="rust rust-example-rendered">
|
||
<span class="kw">let</span> <span class="ident">res</span> <span class="op">=</span> <span class="ident">App</span>::<span class="ident">new</span>(<span class="string">"myprog"</span>)
|
||
.<span class="ident">version</span>(<span class="string">"v1.1"</span>)
|
||
.<span class="ident">setting</span>(<span class="ident">AppSettings</span>::<span class="ident">VersionlessSubcommands</span>)
|
||
.<span class="ident">subcommand</span>(<span class="ident">SubCommand</span>::<span class="ident">with_name</span>(<span class="string">"test"</span>))
|
||
.<span class="ident">get_matches_from_safe</span>(<span class="macro">vec</span><span class="macro">!</span>[
|
||
<span class="string">"myprog"</span>, <span class="string">"test"</span>, <span class="string">"-V"</span>
|
||
]);
|
||
<span class="macro">assert</span><span class="macro">!</span>(<span class="ident">res</span>.<span class="ident">is_err</span>());
|
||
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">res</span>.<span class="ident">unwrap_err</span>().<span class="ident">kind</span>, <span class="ident">ErrorKind</span>::<span class="ident">UnknownArgument</span>);</pre></div>
|
||
</div><span id="variant.WaitOnError" class="variant small-section-header"><a href="#variant.WaitOnError" class="anchor field"></a><code id='WaitOnError.v'>WaitOnError</code></span><div class='docblock'><p>Will display a message "Press [ENTER]/[RETURN] to continue..." and wait for user before
|
||
exiting</p>
|
||
<p>This is most useful when writing an application which is run from a GUI shortcut, or on
|
||
Windows where a user tries to open the binary by double-clicking instead of using the
|
||
command line.</p>
|
||
<p><strong>NOTE:</strong> This setting is <strong>not</strong> recursive with <a href="./struct.SubCommand.html"><code>SubCommand</code></a>s, meaning if you wish this
|
||
behavior for all subcommands, you must set this on each command (needing this is extremely
|
||
rare)</p>
|
||
<h1 id="examples-30" class="section-header"><a href="#examples-30">Examples</a></h1>
|
||
<div class="example-wrap"><pre class="rust rust-example-rendered">
|
||
<span class="ident">App</span>::<span class="ident">new</span>(<span class="string">"myprog"</span>)
|
||
.<span class="ident">setting</span>(<span class="ident">AppSettings</span>::<span class="ident">WaitOnError</span>)</pre></div>
|
||
</div><h2 id='implementations' class='small-section-header'>Trait Implementations<a href='#implementations' class='anchor'></a></h2><div id='implementations-list'><h3 id='impl-Clone' class='impl'><code class='in-band'>impl <a class="trait" href="https://doc.rust-lang.org/nightly/core/clone/trait.Clone.html" title="trait core::clone::Clone">Clone</a> for <a class="enum" href="../clap/enum.AppSettings.html" title="enum clap::AppSettings">AppSettings</a></code><a href='#impl-Clone' class='anchor'></a><a class='srclink' href='../src/clap/app/settings.rs.html#129' title='goto source code'>[src]</a></h3><div class='impl-items'><h4 id='method.clone' class="method hidden"><code id='clone.v'>fn <a href='https://doc.rust-lang.org/nightly/core/clone/trait.Clone.html#tymethod.clone' class='fnname'>clone</a>(&self) -> <a class="enum" href="../clap/enum.AppSettings.html" title="enum clap::AppSettings">AppSettings</a></code><a class='srclink' href='../src/clap/app/settings.rs.html#129' title='goto source code'>[src]</a></h4><div class='docblock hidden'><p>Returns a copy of the value. <a href="https://doc.rust-lang.org/nightly/core/clone/trait.Clone.html#tymethod.clone">Read more</a></p>
|
||
</div><h4 id='method.clone_from' class="method hidden"><code id='clone_from.v'>fn <a href='https://doc.rust-lang.org/nightly/core/clone/trait.Clone.html#method.clone_from' class='fnname'>clone_from</a>(&mut self, source: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.reference.html">&</a>Self)</code><span class='since' title='Stable since Rust version 1.0.0'>1.0.0</span><a class='srclink' href='https://doc.rust-lang.org/nightly/src/core/clone.rs.html#131-133' title='goto source code'>[src]</a></h4><div class='docblock hidden'><p>Performs copy-assignment from <code>source</code>. <a href="https://doc.rust-lang.org/nightly/core/clone/trait.Clone.html#method.clone_from">Read more</a></p>
|
||
</div></div><h3 id='impl-PartialEq%3CAppSettings%3E' class='impl'><code class='in-band'>impl <a class="trait" href="https://doc.rust-lang.org/nightly/core/cmp/trait.PartialEq.html" title="trait core::cmp::PartialEq">PartialEq</a><<a class="enum" href="../clap/enum.AppSettings.html" title="enum clap::AppSettings">AppSettings</a>> for <a class="enum" href="../clap/enum.AppSettings.html" title="enum clap::AppSettings">AppSettings</a></code><a href='#impl-PartialEq%3CAppSettings%3E' class='anchor'></a><a class='srclink' href='../src/clap/app/settings.rs.html#129' title='goto source code'>[src]</a></h3><div class='impl-items'><h4 id='method.eq' class="method hidden"><code id='eq.v'>fn <a href='https://doc.rust-lang.org/nightly/core/cmp/trait.PartialEq.html#tymethod.eq' class='fnname'>eq</a>(&self, other: &<a class="enum" href="../clap/enum.AppSettings.html" title="enum clap::AppSettings">AppSettings</a>) -> <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.bool.html">bool</a></code><a class='srclink' href='../src/clap/app/settings.rs.html#129' title='goto source code'>[src]</a></h4><div class='docblock hidden'><p>This method tests for <code>self</code> and <code>other</code> values to be equal, and is used by <code>==</code>. <a href="https://doc.rust-lang.org/nightly/core/cmp/trait.PartialEq.html#tymethod.eq">Read more</a></p>
|
||
</div><h4 id='method.ne' class="method hidden"><code id='ne.v'><span class="docblock attributes">#[must_use]
|
||
</span>fn <a href='https://doc.rust-lang.org/nightly/core/cmp/trait.PartialEq.html#method.ne' class='fnname'>ne</a>(&self, other: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.reference.html">&</a>Rhs) -> <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.bool.html">bool</a></code><span class='since' title='Stable since Rust version 1.0.0'>1.0.0</span><a class='srclink' href='https://doc.rust-lang.org/nightly/src/core/cmp.rs.html#200' title='goto source code'>[src]</a></h4><div class='docblock hidden'><p>This method tests for <code>!=</code>.</p>
|
||
</div></div><h3 id='impl-Copy' class='impl'><code class='in-band'>impl <a class="trait" href="https://doc.rust-lang.org/nightly/core/marker/trait.Copy.html" title="trait core::marker::Copy">Copy</a> for <a class="enum" href="../clap/enum.AppSettings.html" title="enum clap::AppSettings">AppSettings</a></code><a href='#impl-Copy' class='anchor'></a><a class='srclink' href='../src/clap/app/settings.rs.html#129' title='goto source code'>[src]</a></h3><div class='impl-items'></div><h3 id='impl-Debug' class='impl'><code class='in-band'>impl <a class="trait" href="https://doc.rust-lang.org/nightly/core/fmt/trait.Debug.html" title="trait core::fmt::Debug">Debug</a> for <a class="enum" href="../clap/enum.AppSettings.html" title="enum clap::AppSettings">AppSettings</a></code><a href='#impl-Debug' class='anchor'></a><a class='srclink' href='../src/clap/app/settings.rs.html#129' title='goto source code'>[src]</a></h3><div class='impl-items'><h4 id='method.fmt' class="method hidden"><code id='fmt.v'>fn <a href='https://doc.rust-lang.org/nightly/core/fmt/trait.Debug.html#tymethod.fmt' class='fnname'>fmt</a>(&self, f: &mut <a class="struct" href="https://doc.rust-lang.org/nightly/core/fmt/struct.Formatter.html" title="struct core::fmt::Formatter">Formatter</a>) -> <a class="type" href="https://doc.rust-lang.org/nightly/core/fmt/type.Result.html" title="type core::fmt::Result">Result</a></code><a class='srclink' href='../src/clap/app/settings.rs.html#129' title='goto source code'>[src]</a></h4><div class='docblock hidden'><p>Formats the value using the given formatter. <a href="https://doc.rust-lang.org/nightly/core/fmt/trait.Debug.html#tymethod.fmt">Read more</a></p>
|
||
</div></div><h3 id='impl-FromStr' class='impl'><code class='in-band'>impl <a class="trait" href="https://doc.rust-lang.org/nightly/core/str/trait.FromStr.html" title="trait core::str::FromStr">FromStr</a> for <a class="enum" href="../clap/enum.AppSettings.html" title="enum clap::AppSettings">AppSettings</a></code><a href='#impl-FromStr' class='anchor'></a><a class='srclink' href='../src/clap/app/settings.rs.html#982-1024' title='goto source code'>[src]</a></h3><div class='impl-items'><h4 id='associatedtype.Err' class="type"><code id='Err.t'>type <a href='https://doc.rust-lang.org/nightly/core/str/trait.FromStr.html#associatedtype.Err' class="type">Err</a> = <a class="struct" href="https://doc.rust-lang.org/nightly/alloc/string/struct.String.html" title="struct alloc::string::String">String</a></code></h4><div class='docblock'><p>The associated error which can be returned from parsing.</p>
|
||
</div><h4 id='method.from_str' class="method hidden"><code id='from_str.v'>fn <a href='https://doc.rust-lang.org/nightly/core/str/trait.FromStr.html#tymethod.from_str' class='fnname'>from_str</a>(s: &<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.str.html">str</a>) -> <a class="enum" href="https://doc.rust-lang.org/nightly/core/result/enum.Result.html" title="enum core::result::Result">Result</a><Self, Self::<a class="type" href="https://doc.rust-lang.org/nightly/core/str/trait.FromStr.html#associatedtype.Err" title="type core::str::FromStr::Err">Err</a>></code><a class='srclink' href='../src/clap/app/settings.rs.html#984-1023' title='goto source code'>[src]</a></h4><div class='docblock hidden'><p>Parses a string <code>s</code> to return a value of this type. <a href="https://doc.rust-lang.org/nightly/core/str/trait.FromStr.html#tymethod.from_str">Read more</a></p>
|
||
</div></div></div><h2 id='synthetic-implementations' class='small-section-header'>Auto Trait Implementations<a href='#synthetic-implementations' class='anchor'></a></h2><div id='synthetic-implementations-list'><h3 id='impl-Sync' class='impl'><code class='in-band'>impl <a class="trait" href="https://doc.rust-lang.org/nightly/core/marker/trait.Sync.html" title="trait core::marker::Sync">Sync</a> for <a class="enum" href="../clap/enum.AppSettings.html" title="enum clap::AppSettings">AppSettings</a></code><a href='#impl-Sync' class='anchor'></a></h3><div class='impl-items'></div><h3 id='impl-Send' class='impl'><code class='in-band'>impl <a class="trait" href="https://doc.rust-lang.org/nightly/core/marker/trait.Send.html" title="trait core::marker::Send">Send</a> for <a class="enum" href="../clap/enum.AppSettings.html" title="enum clap::AppSettings">AppSettings</a></code><a href='#impl-Send' class='anchor'></a></h3><div class='impl-items'></div><h3 id='impl-Unpin' class='impl'><code class='in-band'>impl <a class="trait" href="https://doc.rust-lang.org/nightly/core/marker/trait.Unpin.html" title="trait core::marker::Unpin">Unpin</a> for <a class="enum" href="../clap/enum.AppSettings.html" title="enum clap::AppSettings">AppSettings</a></code><a href='#impl-Unpin' class='anchor'></a></h3><div class='impl-items'></div><h3 id='impl-RefUnwindSafe' class='impl'><code class='in-band'>impl <a class="trait" href="https://doc.rust-lang.org/nightly/std/panic/trait.RefUnwindSafe.html" title="trait std::panic::RefUnwindSafe">RefUnwindSafe</a> for <a class="enum" href="../clap/enum.AppSettings.html" title="enum clap::AppSettings">AppSettings</a></code><a href='#impl-RefUnwindSafe' class='anchor'></a></h3><div class='impl-items'></div><h3 id='impl-UnwindSafe' class='impl'><code class='in-band'>impl <a class="trait" href="https://doc.rust-lang.org/nightly/std/panic/trait.UnwindSafe.html" title="trait std::panic::UnwindSafe">UnwindSafe</a> for <a class="enum" href="../clap/enum.AppSettings.html" title="enum clap::AppSettings">AppSettings</a></code><a href='#impl-UnwindSafe' class='anchor'></a></h3><div class='impl-items'></div></div><h2 id='blanket-implementations' class='small-section-header'>Blanket Implementations<a href='#blanket-implementations' class='anchor'></a></h2><div id='blanket-implementations-list'><h3 id='impl-Into%3CU%3E' class='impl'><code class='in-band'>impl<T, U> <a class="trait" href="https://doc.rust-lang.org/nightly/core/convert/trait.Into.html" title="trait core::convert::Into">Into</a><U> for T <span class="where fmt-newline">where<br> U: <a class="trait" href="https://doc.rust-lang.org/nightly/core/convert/trait.From.html" title="trait core::convert::From">From</a><T>, </span></code><a href='#impl-Into%3CU%3E' class='anchor'></a><a class='srclink' href='https://doc.rust-lang.org/nightly/src/core/convert.rs.html#543-548' title='goto source code'>[src]</a></h3><div class='impl-items'><h4 id='method.into' class="method hidden"><code id='into.v'>fn <a href='https://doc.rust-lang.org/nightly/core/convert/trait.Into.html#tymethod.into' class='fnname'>into</a>(self) -> U</code><a class='srclink' href='https://doc.rust-lang.org/nightly/src/core/convert.rs.html#545-547' title='goto source code'>[src]</a></h4><div class='docblock hidden'><p>Performs the conversion.</p>
|
||
</div></div><h3 id='impl-From%3CT%3E' class='impl'><code class='in-band'>impl<T> <a class="trait" href="https://doc.rust-lang.org/nightly/core/convert/trait.From.html" title="trait core::convert::From">From</a><T> for T</code><a href='#impl-From%3CT%3E' class='anchor'></a><a class='srclink' href='https://doc.rust-lang.org/nightly/src/core/convert.rs.html#552-554' title='goto source code'>[src]</a></h3><div class='impl-items'><h4 id='method.from' class="method hidden"><code id='from.v'>fn <a href='https://doc.rust-lang.org/nightly/core/convert/trait.From.html#tymethod.from' class='fnname'>from</a>(t: T) -> T</code><a class='srclink' href='https://doc.rust-lang.org/nightly/src/core/convert.rs.html#553' title='goto source code'>[src]</a></h4><div class='docblock hidden'><p>Performs the conversion.</p>
|
||
</div></div><h3 id='impl-ToOwned' class='impl'><code class='in-band'>impl<T> <a class="trait" href="https://doc.rust-lang.org/nightly/alloc/borrow/trait.ToOwned.html" title="trait alloc::borrow::ToOwned">ToOwned</a> for T <span class="where fmt-newline">where<br> T: <a class="trait" href="https://doc.rust-lang.org/nightly/core/clone/trait.Clone.html" title="trait core::clone::Clone">Clone</a>, </span></code><a href='#impl-ToOwned' class='anchor'></a><a class='srclink' href='https://doc.rust-lang.org/nightly/src/alloc/borrow.rs.html#81-92' title='goto source code'>[src]</a></h3><div class='impl-items'><h4 id='associatedtype.Owned' class="type"><code id='Owned.t'>type <a href='https://doc.rust-lang.org/nightly/alloc/borrow/trait.ToOwned.html#associatedtype.Owned' class="type">Owned</a> = T</code></h4><div class='docblock'><p>The resulting type after obtaining ownership.</p>
|
||
</div><h4 id='method.to_owned' class="method hidden"><code id='to_owned.v'>fn <a href='https://doc.rust-lang.org/nightly/alloc/borrow/trait.ToOwned.html#tymethod.to_owned' class='fnname'>to_owned</a>(&self) -> T</code><a class='srclink' href='https://doc.rust-lang.org/nightly/src/alloc/borrow.rs.html#85-87' title='goto source code'>[src]</a></h4><div class='docblock hidden'><p>Creates owned data from borrowed data, usually by cloning. <a href="https://doc.rust-lang.org/nightly/alloc/borrow/trait.ToOwned.html#tymethod.to_owned">Read more</a></p>
|
||
</div><h4 id='method.clone_into' class="method hidden"><code id='clone_into.v'>fn <a href='https://doc.rust-lang.org/nightly/alloc/borrow/trait.ToOwned.html#method.clone_into' class='fnname'>clone_into</a>(&self, target: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.reference.html">&mut </a>T)</code><a class='srclink' href='https://doc.rust-lang.org/nightly/src/alloc/borrow.rs.html#89-91' title='goto source code'>[src]</a></h4><div class='stability hidden'><div class='stab unstable'><details><summary><span class='emoji'>🔬</span> This is a nightly-only experimental API. (<code>toowned_clone_into</code>)</summary><p>recently added</p>
|
||
</details></div></div><div class='docblock hidden'><p>Uses borrowed data to replace owned data, usually by cloning. <a href="https://doc.rust-lang.org/nightly/alloc/borrow/trait.ToOwned.html#method.clone_into">Read more</a></p>
|
||
</div></div><h3 id='impl-TryFrom%3CU%3E' class='impl'><code class='in-band'>impl<T, U> <a class="trait" href="https://doc.rust-lang.org/nightly/core/convert/trait.TryFrom.html" title="trait core::convert::TryFrom">TryFrom</a><U> for T <span class="where fmt-newline">where<br> U: <a class="trait" href="https://doc.rust-lang.org/nightly/core/convert/trait.Into.html" title="trait core::convert::Into">Into</a><T>, </span></code><a href='#impl-TryFrom%3CU%3E' class='anchor'></a><a class='srclink' href='https://doc.rust-lang.org/nightly/src/core/convert.rs.html#571-577' title='goto source code'>[src]</a></h3><div class='impl-items'><h4 id='associatedtype.Error' class="type"><code id='Error.t'>type <a href='https://doc.rust-lang.org/nightly/core/convert/trait.TryFrom.html#associatedtype.Error' class="type">Error</a> = <a class="enum" href="https://doc.rust-lang.org/nightly/core/convert/enum.Infallible.html" title="enum core::convert::Infallible">Infallible</a></code></h4><div class='docblock'><p>The type returned in the event of a conversion error.</p>
|
||
</div><h4 id='method.try_from' class="method hidden"><code id='try_from.v'>fn <a href='https://doc.rust-lang.org/nightly/core/convert/trait.TryFrom.html#tymethod.try_from' class='fnname'>try_from</a>(value: U) -> <a class="enum" href="https://doc.rust-lang.org/nightly/core/result/enum.Result.html" title="enum core::result::Result">Result</a><T, <T as <a class="trait" href="https://doc.rust-lang.org/nightly/core/convert/trait.TryFrom.html" title="trait core::convert::TryFrom">TryFrom</a><U>>::<a class="type" href="https://doc.rust-lang.org/nightly/core/convert/trait.TryFrom.html#associatedtype.Error" title="type core::convert::TryFrom::Error">Error</a>></code><a class='srclink' href='https://doc.rust-lang.org/nightly/src/core/convert.rs.html#574-576' title='goto source code'>[src]</a></h4><div class='docblock hidden'><p>Performs the conversion.</p>
|
||
</div></div><h3 id='impl-TryInto%3CU%3E' class='impl'><code class='in-band'>impl<T, U> <a class="trait" href="https://doc.rust-lang.org/nightly/core/convert/trait.TryInto.html" title="trait core::convert::TryInto">TryInto</a><U> for T <span class="where fmt-newline">where<br> U: <a class="trait" href="https://doc.rust-lang.org/nightly/core/convert/trait.TryFrom.html" title="trait core::convert::TryFrom">TryFrom</a><T>, </span></code><a href='#impl-TryInto%3CU%3E' class='anchor'></a><a class='srclink' href='https://doc.rust-lang.org/nightly/src/core/convert.rs.html#559-566' title='goto source code'>[src]</a></h3><div class='impl-items'><h4 id='associatedtype.Error-1' class="type"><code id='Error.t-1'>type <a href='https://doc.rust-lang.org/nightly/core/convert/trait.TryInto.html#associatedtype.Error' class="type">Error</a> = <U as <a class="trait" href="https://doc.rust-lang.org/nightly/core/convert/trait.TryFrom.html" title="trait core::convert::TryFrom">TryFrom</a><T>>::<a class="type" href="https://doc.rust-lang.org/nightly/core/convert/trait.TryFrom.html#associatedtype.Error" title="type core::convert::TryFrom::Error">Error</a></code></h4><div class='docblock'><p>The type returned in the event of a conversion error.</p>
|
||
</div><h4 id='method.try_into' class="method hidden"><code id='try_into.v'>fn <a href='https://doc.rust-lang.org/nightly/core/convert/trait.TryInto.html#tymethod.try_into' class='fnname'>try_into</a>(self) -> <a class="enum" href="https://doc.rust-lang.org/nightly/core/result/enum.Result.html" title="enum core::result::Result">Result</a><U, <U as <a class="trait" href="https://doc.rust-lang.org/nightly/core/convert/trait.TryFrom.html" title="trait core::convert::TryFrom">TryFrom</a><T>>::<a class="type" href="https://doc.rust-lang.org/nightly/core/convert/trait.TryFrom.html#associatedtype.Error" title="type core::convert::TryFrom::Error">Error</a>></code><a class='srclink' href='https://doc.rust-lang.org/nightly/src/core/convert.rs.html#563-565' title='goto source code'>[src]</a></h4><div class='docblock hidden'><p>Performs the conversion.</p>
|
||
</div></div><h3 id='impl-BorrowMut%3CT%3E' class='impl'><code class='in-band'>impl<T> <a class="trait" href="https://doc.rust-lang.org/nightly/core/borrow/trait.BorrowMut.html" title="trait core::borrow::BorrowMut">BorrowMut</a><T> for T <span class="where fmt-newline">where<br> T: ?<a class="trait" href="https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html" title="trait core::marker::Sized">Sized</a>, </span></code><a href='#impl-BorrowMut%3CT%3E' class='anchor'></a><a class='srclink' href='https://doc.rust-lang.org/nightly/src/core/borrow.rs.html#218-220' title='goto source code'>[src]</a></h3><div class='impl-items'><h4 id='method.borrow_mut' class="method hidden"><code id='borrow_mut.v'>fn <a href='https://doc.rust-lang.org/nightly/core/borrow/trait.BorrowMut.html#tymethod.borrow_mut' class='fnname'>borrow_mut</a>(&mut self) -> <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.reference.html">&mut </a>T</code><a class='srclink' href='https://doc.rust-lang.org/nightly/src/core/borrow.rs.html#219' title='goto source code'>[src]</a></h4><div class='docblock hidden'><p>Mutably borrows from an owned value. <a href="https://doc.rust-lang.org/nightly/core/borrow/trait.BorrowMut.html#tymethod.borrow_mut">Read more</a></p>
|
||
</div></div><h3 id='impl-Borrow%3CT%3E' class='impl'><code class='in-band'>impl<T> <a class="trait" href="https://doc.rust-lang.org/nightly/core/borrow/trait.Borrow.html" title="trait core::borrow::Borrow">Borrow</a><T> for T <span class="where fmt-newline">where<br> T: ?<a class="trait" href="https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html" title="trait core::marker::Sized">Sized</a>, </span></code><a href='#impl-Borrow%3CT%3E' class='anchor'></a><a class='srclink' href='https://doc.rust-lang.org/nightly/src/core/borrow.rs.html#213-215' title='goto source code'>[src]</a></h3><div class='impl-items'><h4 id='method.borrow' class="method hidden"><code id='borrow.v'>fn <a href='https://doc.rust-lang.org/nightly/core/borrow/trait.Borrow.html#tymethod.borrow' class='fnname'>borrow</a>(&self) -> <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.reference.html">&</a>T</code><a class='srclink' href='https://doc.rust-lang.org/nightly/src/core/borrow.rs.html#214' title='goto source code'>[src]</a></h4><div class='docblock hidden'><p>Immutably borrows from an owned value. <a href="https://doc.rust-lang.org/nightly/core/borrow/trait.Borrow.html#tymethod.borrow">Read more</a></p>
|
||
</div></div><h3 id='impl-Any' class='impl'><code class='in-band'>impl<T> <a class="trait" href="https://doc.rust-lang.org/nightly/core/any/trait.Any.html" title="trait core::any::Any">Any</a> for T <span class="where fmt-newline">where<br> T: 'static + ?<a class="trait" href="https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html" title="trait core::marker::Sized">Sized</a>, </span></code><a href='#impl-Any' class='anchor'></a><a class='srclink' href='https://doc.rust-lang.org/nightly/src/core/any.rs.html#100-102' title='goto source code'>[src]</a></h3><div class='impl-items'><h4 id='method.type_id' class="method hidden"><code id='type_id.v'>fn <a href='https://doc.rust-lang.org/nightly/core/any/trait.Any.html#tymethod.type_id' class='fnname'>type_id</a>(&self) -> <a class="struct" href="https://doc.rust-lang.org/nightly/core/any/struct.TypeId.html" title="struct core::any::TypeId">TypeId</a></code><a class='srclink' href='https://doc.rust-lang.org/nightly/src/core/any.rs.html#101' title='goto source code'>[src]</a></h4><div class='docblock hidden'><p>Gets the <code>TypeId</code> of <code>self</code>. <a href="https://doc.rust-lang.org/nightly/core/any/trait.Any.html#tymethod.type_id">Read more</a></p>
|
||
</div></div></div></section><section id="search" class="content hidden"></section><section class="footer"></section><aside id="help" class="hidden"><div><h1 class="hidden">Help</h1><div class="shortcuts"><h2>Keyboard Shortcuts</h2><dl><dt><kbd>?</kbd></dt><dd>Show this help dialog</dd><dt><kbd>S</kbd></dt><dd>Focus the search field</dd><dt><kbd>↑</kbd></dt><dd>Move up in search results</dd><dt><kbd>↓</kbd></dt><dd>Move down in search results</dd><dt><kbd>↹</kbd></dt><dd>Switch tab</dd><dt><kbd>⏎</kbd></dt><dd>Go to active search result</dd><dt><kbd>+</kbd></dt><dd>Expand all sections</dd><dt><kbd>-</kbd></dt><dd>Collapse all sections</dd></dl></div><div class="infos"><h2>Search Tricks</h2><p>Prefix searches with a type followed by a colon (e.g., <code>fn:</code>) to restrict the search to a given type.</p><p>Accepted types are: <code>fn</code>, <code>mod</code>, <code>struct</code>, <code>enum</code>, <code>trait</code>, <code>type</code>, <code>macro</code>, and <code>const</code>.</p><p>Search functions by type signature (e.g., <code>vec -> usize</code> or <code>* -> vec</code>)</p><p>Search multiple things at once by splitting your query with comma (e.g., <code>str,u8</code> or <code>String,struct:Vec,test</code>)</p></div></div></aside><script>window.rootPath = "../";window.currentCrate = "clap";</script><script src="../aliases.js"></script><script src="../main.js"></script><script defer src="../search-index.js"></script></body></html> |