mirror of
https://github.com/edg-l/edlang.git
synced 2024-11-23 16:38:24 +00:00
473 lines
80 KiB
HTML
473 lines
80 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="An object describing the configuration of a `Regex`."><title>Config in regex_automata::meta - Rust</title><link rel="preload" as="font" type="font/woff2" crossorigin href="../../static.files/SourceSerif4-Regular-46f98efaafac5295.ttf.woff2"><link rel="preload" as="font" type="font/woff2" crossorigin href="../../static.files/FiraSans-Regular-018c141bf0843ffd.woff2"><link rel="preload" as="font" type="font/woff2" crossorigin href="../../static.files/FiraSans-Medium-8f9a781e4970d388.woff2"><link rel="preload" as="font" type="font/woff2" crossorigin href="../../static.files/SourceCodePro-Regular-562dcc5011b6de7d.ttf.woff2"><link rel="preload" as="font" type="font/woff2" crossorigin href="../../static.files/SourceCodePro-Semibold-d899c5a5c4aeb14a.ttf.woff2"><link rel="stylesheet" href="../../static.files/normalize-76eba96aa4d2e634.css"><link rel="stylesheet" href="../../static.files/rustdoc-ac92e1bbe349e143.css"><meta name="rustdoc-vars" data-root-path="../../" data-static-root-path="../../static.files/" data-current-crate="regex_automata" data-themes="" data-resource-suffix="" data-rustdoc-version="1.76.0 (07dca489a 2024-02-04)" data-channel="1.76.0" data-search-js="search-2b6ce74ff89ae146.js" data-settings-js="settings-4313503d2e1961c2.js" ><script src="../../static.files/storage-f2adc0d6ca4d09fb.js"></script><script defer src="sidebar-items.js"></script><script defer src="../../static.files/main-305769736d49e732.js"></script><noscript><link rel="stylesheet" href="../../static.files/noscript-feafe1bb7466e4bd.css"></noscript><link rel="alternate icon" type="image/png" href="../../static.files/favicon-16x16-8b506e7a72182f1c.png"><link rel="alternate icon" type="image/png" href="../../static.files/favicon-32x32-422f7d1d52889060.png"><link rel="icon" type="image/svg+xml" href="../../static.files/favicon-2c020d218678b618.svg"></head><body class="rustdoc struct"><!--[if lte IE 11]><div class="warning">This old browser is unsupported and will most likely display funky things.</div><![endif]--><nav class="mobile-topbar"><button class="sidebar-menu-toggle">☰</button></nav><nav class="sidebar"><div class="sidebar-crate"><h2><a href="../../regex_automata/index.html">regex_automata</a><span class="version">0.4.5</span></h2></div><h2 class="location"><a href="#">Config</a></h2><div class="sidebar-elems"><section><h3><a href="#implementations">Methods</a></h3><ul class="block method"><li><a href="#method.auto_prefilter">auto_prefilter</a></li><li><a href="#method.backtrack">backtrack</a></li><li><a href="#method.byte_classes">byte_classes</a></li><li><a href="#method.dfa">dfa</a></li><li><a href="#method.dfa_size_limit">dfa_size_limit</a></li><li><a href="#method.dfa_state_limit">dfa_state_limit</a></li><li><a href="#method.get_auto_prefilter">get_auto_prefilter</a></li><li><a href="#method.get_backtrack">get_backtrack</a></li><li><a href="#method.get_byte_classes">get_byte_classes</a></li><li><a href="#method.get_dfa">get_dfa</a></li><li><a href="#method.get_dfa_size_limit">get_dfa_size_limit</a></li><li><a href="#method.get_dfa_state_limit">get_dfa_state_limit</a></li><li><a href="#method.get_hybrid">get_hybrid</a></li><li><a href="#method.get_hybrid_cache_capacity">get_hybrid_cache_capacity</a></li><li><a href="#method.get_line_terminator">get_line_terminator</a></li><li><a href="#method.get_match_kind">get_match_kind</a></li><li><a href="#method.get_nfa_size_limit">get_nfa_size_limit</a></li><li><a href="#method.get_onepass">get_onepass</a></li><li><a href="#method.get_onepass_size_limit">get_onepass_size_limit</a></li><li><a href="#method.get_prefilter">get_prefilter</a></li><li><a href="#method.get_utf8_empty">get_utf8_empty</a></li><li><a href="#method.get_which_captures">get_which_captures</a></li><li><a href="#method.hybrid">hybrid</a></li><li><a href="#method.hybrid_cache_capacity">hybrid_cache_capacity</a></li><li><a hre
|
|||
|
|
<main><div class="width-limiter"><nav class="sub"><form class="search-form"><span></span><div id="sidebar-button" tabindex="-1"><a href="../../regex_automata/all.html" title="show sidebar"></a></div><input class="search-input" name="search" aria-label="Run search in the documentation" autocomplete="off" spellcheck="false" placeholder="Click or press ‘S’ to search, ‘?’ for more options…" type="search"><div id="help-button" tabindex="-1"><a href="../../help.html" title="help">?</a></div><div id="settings-menu" tabindex="-1"><a href="../../settings.html" title="settings"><img width="22" height="22" alt="Change settings" src="../../static.files/wheel-7b819b6101059cd0.svg"></a></div></form></nav><section id="main-content" class="content"><div class="main-heading"><h1>Struct <a href="../index.html">regex_automata</a>::<wbr><a href="index.html">meta</a>::<wbr><a class="struct" href="#">Config</a><button id="copy-path" title="Copy item path to clipboard"><img src="../../static.files/clipboard-7571035ce49a181d.svg" width="19" height="18" alt="Copy item path"></button></h1><span class="out-of-band"><a class="src" href="../../src/regex_automata/meta/regex.rs.html#2428-2452">source</a> · <button id="toggle-all-docs" title="collapse all docs">[<span>−</span>]</button></span></div><pre class="rust item-decl"><code>pub struct Config { <span class="comment">/* private fields */</span> }</code></pre><details class="toggle top-doc" open><summary class="hideme"><span>Expand description</span></summary><div class="docblock"><p>An object describing the configuration of a <code>Regex</code>.</p>
|
|||
|
|
<p>This configuration only includes options for the
|
|||
|
|
non-syntax behavior of a <code>Regex</code>, and can be applied via the
|
|||
|
|
<a href="struct.Builder.html#method.configure" title="method regex_automata::meta::Builder::configure"><code>Builder::configure</code></a> method. For configuring the syntax options, see
|
|||
|
|
<a href="../util/syntax/struct.Config.html" title="struct regex_automata::util::syntax::Config"><code>util::syntax::Config</code></a>.</p>
|
|||
|
|
<h2 id="example-lower-the-nfa-size-limit"><a href="#example-lower-the-nfa-size-limit">Example: lower the NFA size limit</a></h2>
|
|||
|
|
<p>In some cases, the default size limit might be too big. The size limit can
|
|||
|
|
be lowered, which will prevent large regex patterns from compiling.</p>
|
|||
|
|
|
|||
|
|
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use </span>regex_automata::meta::Regex;
|
|||
|
|
|
|||
|
|
<span class="kw">let </span>result = Regex::builder()
|
|||
|
|
.configure(Regex::config().nfa_size_limit(<span class="prelude-val">Some</span>(<span class="number">20 </span>* (<span class="number">1</span><<<span class="number">10</span>))))
|
|||
|
|
<span class="comment">// Not even 20KB is enough to build a single large Unicode class!
|
|||
|
|
</span>.build(<span class="string">r"\pL"</span>);
|
|||
|
|
<span class="macro">assert!</span>(result.is_err());
|
|||
|
|
</code></pre></div>
|
|||
|
|
</div></details><h2 id="implementations" class="section-header">Implementations<a href="#implementations" class="anchor">§</a></h2><div id="implementations-list"><details class="toggle implementors-toggle" open><summary><section id="impl-Config" class="impl"><a class="src rightside" href="../../src/regex_automata/meta/regex.rs.html#2454-3235">source</a><a href="#impl-Config" class="anchor">§</a><h3 class="code-header">impl <a class="struct" href="struct.Config.html" title="struct regex_automata::meta::Config">Config</a></h3></section></summary><div class="impl-items"><details class="toggle method-toggle" open><summary><section id="method.new" class="method"><a class="src rightside" href="../../src/regex_automata/meta/regex.rs.html#2456-2458">source</a><h4 class="code-header">pub fn <a href="#method.new" class="fn">new</a>() -> <a class="struct" href="struct.Config.html" title="struct regex_automata::meta::Config">Config</a></h4></section></summary><div class="docblock"><p>Create a new configuration object for a <code>Regex</code>.</p>
|
|||
|
|
</div></details><details class="toggle method-toggle" open><summary><section id="method.match_kind" class="method"><a class="src rightside" href="../../src/regex_automata/meta/regex.rs.html#2490-2492">source</a><h4 class="code-header">pub fn <a href="#method.match_kind" class="fn">match_kind</a>(self, kind: <a class="enum" href="../enum.MatchKind.html" title="enum regex_automata::MatchKind">MatchKind</a>) -> <a class="struct" href="struct.Config.html" title="struct regex_automata::meta::Config">Config</a></h4></section></summary><div class="docblock"><p>Set the match semantics for a <code>Regex</code>.</p>
|
|||
|
|
<p>The default value is <a href="../enum.MatchKind.html#variant.LeftmostFirst" title="variant regex_automata::MatchKind::LeftmostFirst"><code>MatchKind::LeftmostFirst</code></a>.</p>
|
|||
|
|
<h5 id="example"><a href="#example">Example</a></h5>
|
|||
|
|
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use </span>regex_automata::{meta::Regex, Match, MatchKind};
|
|||
|
|
|
|||
|
|
<span class="comment">// By default, leftmost-first semantics are used, which
|
|||
|
|
// disambiguates matches at the same position by selecting
|
|||
|
|
// the one that corresponds earlier in the pattern.
|
|||
|
|
</span><span class="kw">let </span>re = Regex::new(<span class="string">"sam|samwise"</span>)<span class="question-mark">?</span>;
|
|||
|
|
<span class="macro">assert_eq!</span>(<span class="prelude-val">Some</span>(Match::must(<span class="number">0</span>, <span class="number">0</span>..<span class="number">3</span>)), re.find(<span class="string">"samwise"</span>));
|
|||
|
|
|
|||
|
|
<span class="comment">// But with 'all' semantics, match priority is ignored
|
|||
|
|
// and all match states are included. When coupled with
|
|||
|
|
// a leftmost search, the search will report the last
|
|||
|
|
// possible match.
|
|||
|
|
</span><span class="kw">let </span>re = Regex::builder()
|
|||
|
|
.configure(Regex::config().match_kind(MatchKind::All))
|
|||
|
|
.build(<span class="string">"sam|samwise"</span>)<span class="question-mark">?</span>;
|
|||
|
|
<span class="macro">assert_eq!</span>(<span class="prelude-val">Some</span>(Match::must(<span class="number">0</span>, <span class="number">0</span>..<span class="number">7</span>)), re.find(<span class="string">"samwise"</span>));
|
|||
|
|
<span class="comment">// Beware that this can lead to skipping matches!
|
|||
|
|
// Usually 'all' is used for anchored reverse searches
|
|||
|
|
// only, or for overlapping searches.
|
|||
|
|
</span><span class="macro">assert_eq!</span>(<span class="prelude-val">Some</span>(Match::must(<span class="number">0</span>, <span class="number">4</span>..<span class="number">11</span>)), re.find(<span class="string">"sam samwise"</span>));
|
|||
|
|
</code></pre></div>
|
|||
|
|
</div></details><details class="toggle method-toggle" open><summary><section id="method.utf8_empty" class="method"><a class="src rightside" href="../../src/regex_automata/meta/regex.rs.html#2531-2533">source</a><h4 class="code-header">pub fn <a href="#method.utf8_empty" class="fn">utf8_empty</a>(self, yes: <a class="primitive" href="https://doc.rust-lang.org/1.76.0/std/primitive.bool.html">bool</a>) -> <a class="struct" href="struct.Config.html" title="struct regex_automata::meta::Config">Config</a></h4></section></summary><div class="docblock"><p>Toggles whether empty matches are permitted to occur between the code
|
|||
|
|
units of a UTF-8 encoded codepoint.</p>
|
|||
|
|
<p>This should generally be enabled when search a <code>&str</code> or anything that
|
|||
|
|
you otherwise know is valid UTF-8. It should be disabled in all other
|
|||
|
|
cases. Namely, if the haystack is not valid UTF-8 and this is enabled,
|
|||
|
|
then behavior is unspecified.</p>
|
|||
|
|
<p>By default, this is enabled.</p>
|
|||
|
|
<h5 id="example-1"><a href="#example-1">Example</a></h5>
|
|||
|
|
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use </span>regex_automata::{meta::Regex, Match};
|
|||
|
|
|
|||
|
|
<span class="kw">let </span>re = Regex::new(<span class="string">""</span>)<span class="question-mark">?</span>;
|
|||
|
|
<span class="kw">let </span>got: Vec<Match> = re.find_iter(<span class="string">"☃"</span>).collect();
|
|||
|
|
<span class="comment">// Matches only occur at the beginning and end of the snowman.
|
|||
|
|
</span><span class="macro">assert_eq!</span>(got, <span class="macro">vec!</span>[
|
|||
|
|
Match::must(<span class="number">0</span>, <span class="number">0</span>..<span class="number">0</span>),
|
|||
|
|
Match::must(<span class="number">0</span>, <span class="number">3</span>..<span class="number">3</span>),
|
|||
|
|
]);
|
|||
|
|
|
|||
|
|
<span class="kw">let </span>re = Regex::builder()
|
|||
|
|
.configure(Regex::config().utf8_empty(<span class="bool-val">false</span>))
|
|||
|
|
.build(<span class="string">""</span>)<span class="question-mark">?</span>;
|
|||
|
|
<span class="kw">let </span>got: Vec<Match> = re.find_iter(<span class="string">"☃"</span>).collect();
|
|||
|
|
<span class="comment">// Matches now occur at every position!
|
|||
|
|
</span><span class="macro">assert_eq!</span>(got, <span class="macro">vec!</span>[
|
|||
|
|
Match::must(<span class="number">0</span>, <span class="number">0</span>..<span class="number">0</span>),
|
|||
|
|
Match::must(<span class="number">0</span>, <span class="number">1</span>..<span class="number">1</span>),
|
|||
|
|
Match::must(<span class="number">0</span>, <span class="number">2</span>..<span class="number">2</span>),
|
|||
|
|
Match::must(<span class="number">0</span>, <span class="number">3</span>..<span class="number">3</span>),
|
|||
|
|
]);
|
|||
|
|
|
|||
|
|
<span class="prelude-val">Ok</span>::<(), Box<<span class="kw">dyn </span>std::error::Error>>(())</code></pre></div>
|
|||
|
|
</div></details><details class="toggle method-toggle" open><summary><section id="method.auto_prefilter" class="method"><a class="src rightside" href="../../src/regex_automata/meta/regex.rs.html#2558-2560">source</a><h4 class="code-header">pub fn <a href="#method.auto_prefilter" class="fn">auto_prefilter</a>(self, yes: <a class="primitive" href="https://doc.rust-lang.org/1.76.0/std/primitive.bool.html">bool</a>) -> <a class="struct" href="struct.Config.html" title="struct regex_automata::meta::Config">Config</a></h4></section></summary><div class="docblock"><p>Toggles whether automatic prefilter support is enabled.</p>
|
|||
|
|
<p>If this is disabled and <a href="struct.Config.html#method.prefilter" title="method regex_automata::meta::Config::prefilter"><code>Config::prefilter</code></a> is not set, then the
|
|||
|
|
meta regex engine will not use any prefilters. This can sometimes
|
|||
|
|
be beneficial in cases where you know (or have measured) that the
|
|||
|
|
prefilter leads to overall worse search performance.</p>
|
|||
|
|
<p>By default, this is enabled.</p>
|
|||
|
|
<h5 id="example-2"><a href="#example-2">Example</a></h5>
|
|||
|
|
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use </span>regex_automata::{meta::Regex, Match};
|
|||
|
|
|
|||
|
|
<span class="kw">let </span>re = Regex::builder()
|
|||
|
|
.configure(Regex::config().auto_prefilter(<span class="bool-val">false</span>))
|
|||
|
|
.build(<span class="string">r"Bruce \w+"</span>)<span class="question-mark">?</span>;
|
|||
|
|
<span class="kw">let </span>hay = <span class="string">"Hello Bruce Springsteen!"</span>;
|
|||
|
|
<span class="macro">assert_eq!</span>(<span class="prelude-val">Some</span>(Match::must(<span class="number">0</span>, <span class="number">6</span>..<span class="number">23</span>)), re.find(hay));
|
|||
|
|
|
|||
|
|
<span class="prelude-val">Ok</span>::<(), Box<<span class="kw">dyn </span>std::error::Error>>(())</code></pre></div>
|
|||
|
|
</div></details><details class="toggle method-toggle" open><summary><section id="method.prefilter" class="method"><a class="src rightside" href="../../src/regex_automata/meta/regex.rs.html#2627-2629">source</a><h4 class="code-header">pub fn <a href="#method.prefilter" class="fn">prefilter</a>(self, pre: <a class="enum" href="https://doc.rust-lang.org/1.76.0/core/option/enum.Option.html" title="enum core::option::Option">Option</a><<a class="struct" href="../util/prefilter/struct.Prefilter.html" title="struct regex_automata::util::prefilter::Prefilter">Prefilter</a>>) -> <a class="struct" href="struct.Config.html" title="struct regex_automata::meta::Config">Config</a></h4></section></summary><div class="docblock"><p>Overrides and sets the prefilter to use inside a <code>Regex</code>.</p>
|
|||
|
|
<p>This permits one to forcefully set a prefilter in cases where the
|
|||
|
|
caller knows better than whatever the automatic prefilter logic is
|
|||
|
|
capable of.</p>
|
|||
|
|
<p>By default, this is set to <code>None</code> and an automatic prefilter will be
|
|||
|
|
used if one could be built. (Assuming <a href="struct.Config.html#method.auto_prefilter" title="method regex_automata::meta::Config::auto_prefilter"><code>Config::auto_prefilter</code></a> is
|
|||
|
|
enabled, which it is by default.)</p>
|
|||
|
|
<h5 id="example-3"><a href="#example-3">Example</a></h5>
|
|||
|
|
<p>This example shows how to set your own prefilter. In the case of a
|
|||
|
|
pattern like <code>Bruce \w+</code>, the automatic prefilter is likely to be
|
|||
|
|
constructed in a way that it will look for occurrences of <code>Bruce </code>.
|
|||
|
|
In most cases, this is the best choice. But in some cases, it may be
|
|||
|
|
the case that running <code>memchr</code> on <code>B</code> is the best choice. One can
|
|||
|
|
achieve that behavior by overriding the automatic prefilter logic
|
|||
|
|
and providing a prefilter that just matches <code>B</code>.</p>
|
|||
|
|
|
|||
|
|
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use </span>regex_automata::{
|
|||
|
|
meta::Regex,
|
|||
|
|
util::prefilter::Prefilter,
|
|||
|
|
Match, MatchKind,
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
<span class="kw">let </span>pre = Prefilter::new(MatchKind::LeftmostFirst, <span class="kw-2">&</span>[<span class="string">"B"</span>])
|
|||
|
|
.expect(<span class="string">"a prefilter"</span>);
|
|||
|
|
<span class="kw">let </span>re = Regex::builder()
|
|||
|
|
.configure(Regex::config().prefilter(<span class="prelude-val">Some</span>(pre)))
|
|||
|
|
.build(<span class="string">r"Bruce \w+"</span>)<span class="question-mark">?</span>;
|
|||
|
|
<span class="kw">let </span>hay = <span class="string">"Hello Bruce Springsteen!"</span>;
|
|||
|
|
<span class="macro">assert_eq!</span>(<span class="prelude-val">Some</span>(Match::must(<span class="number">0</span>, <span class="number">6</span>..<span class="number">23</span>)), re.find(hay));
|
|||
|
|
</code></pre></div>
|
|||
|
|
<h5 id="example-incorrect-prefilters-can-lead-to-incorrect-results"><a href="#example-incorrect-prefilters-can-lead-to-incorrect-results">Example: incorrect prefilters can lead to incorrect results!</a></h5>
|
|||
|
|
<p>Be warned that setting an incorrect prefilter can lead to missed
|
|||
|
|
matches. So if you use this option, ensure your prefilter can <em>never</em>
|
|||
|
|
report false negatives. (A false positive is, on the other hand, quite
|
|||
|
|
okay and generally unavoidable.)</p>
|
|||
|
|
|
|||
|
|
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use </span>regex_automata::{
|
|||
|
|
meta::Regex,
|
|||
|
|
util::prefilter::Prefilter,
|
|||
|
|
Match, MatchKind,
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
<span class="kw">let </span>pre = Prefilter::new(MatchKind::LeftmostFirst, <span class="kw-2">&</span>[<span class="string">"Z"</span>])
|
|||
|
|
.expect(<span class="string">"a prefilter"</span>);
|
|||
|
|
<span class="kw">let </span>re = Regex::builder()
|
|||
|
|
.configure(Regex::config().prefilter(<span class="prelude-val">Some</span>(pre)))
|
|||
|
|
.build(<span class="string">r"Bruce \w+"</span>)<span class="question-mark">?</span>;
|
|||
|
|
<span class="kw">let </span>hay = <span class="string">"Hello Bruce Springsteen!"</span>;
|
|||
|
|
<span class="comment">// Oops! No match found, but there should be one!
|
|||
|
|
</span><span class="macro">assert_eq!</span>(<span class="prelude-val">None</span>, re.find(hay));
|
|||
|
|
</code></pre></div>
|
|||
|
|
</div></details><details class="toggle method-toggle" open><summary><section id="method.which_captures" class="method"><a class="src rightside" href="../../src/regex_automata/meta/regex.rs.html#2697-2700">source</a><h4 class="code-header">pub fn <a href="#method.which_captures" class="fn">which_captures</a>(self, which_captures: <a class="enum" href="../nfa/thompson/enum.WhichCaptures.html" title="enum regex_automata::nfa::thompson::WhichCaptures">WhichCaptures</a>) -> <a class="struct" href="struct.Config.html" title="struct regex_automata::meta::Config">Config</a></h4></section></summary><div class="docblock"><p>Configures what kinds of groups are compiled as “capturing” in the
|
|||
|
|
underlying regex engine.</p>
|
|||
|
|
<p>This is set to <a href="../nfa/thompson/enum.WhichCaptures.html#variant.All" title="variant regex_automata::nfa::thompson::WhichCaptures::All"><code>WhichCaptures::All</code></a> by default. Callers may wish to
|
|||
|
|
use <a href="../nfa/thompson/enum.WhichCaptures.html#variant.Implicit" title="variant regex_automata::nfa::thompson::WhichCaptures::Implicit"><code>WhichCaptures::Implicit</code></a> in cases where one wants avoid the
|
|||
|
|
overhead of capture states for explicit groups.</p>
|
|||
|
|
<p>Note that another approach to avoiding the overhead of capture groups
|
|||
|
|
is by using non-capturing groups in the regex pattern. That is,
|
|||
|
|
<code>(?:a)</code> instead of <code>(a)</code>. This option is useful when you can’t control
|
|||
|
|
the concrete syntax but know that you don’t need the underlying capture
|
|||
|
|
states. For example, using <code>WhichCaptures::Implicit</code> will behave as if
|
|||
|
|
all explicit capturing groups in the pattern were non-capturing.</p>
|
|||
|
|
<p>Setting this to <code>WhichCaptures::None</code> is usually not the right thing to
|
|||
|
|
do. When no capture states are compiled, some regex engines (such as
|
|||
|
|
the <code>PikeVM</code>) won’t be able to report match offsets. This will manifest
|
|||
|
|
as no match being found.</p>
|
|||
|
|
<h5 id="example-4"><a href="#example-4">Example</a></h5>
|
|||
|
|
<p>This example demonstrates how the results of capture groups can change
|
|||
|
|
based on this option. First we show the default (all capture groups in
|
|||
|
|
the pattern are capturing):</p>
|
|||
|
|
|
|||
|
|
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use </span>regex_automata::{meta::Regex, Match, Span};
|
|||
|
|
|
|||
|
|
<span class="kw">let </span>re = Regex::new(<span class="string">r"foo([0-9]+)bar"</span>)<span class="question-mark">?</span>;
|
|||
|
|
<span class="kw">let </span>hay = <span class="string">"foo123bar"</span>;
|
|||
|
|
|
|||
|
|
<span class="kw">let </span><span class="kw-2">mut </span>caps = re.create_captures();
|
|||
|
|
re.captures(hay, <span class="kw-2">&mut </span>caps);
|
|||
|
|
<span class="macro">assert_eq!</span>(<span class="prelude-val">Some</span>(Span::from(<span class="number">0</span>..<span class="number">9</span>)), caps.get_group(<span class="number">0</span>));
|
|||
|
|
<span class="macro">assert_eq!</span>(<span class="prelude-val">Some</span>(Span::from(<span class="number">3</span>..<span class="number">6</span>)), caps.get_group(<span class="number">1</span>));
|
|||
|
|
|
|||
|
|
<span class="prelude-val">Ok</span>::<(), Box<<span class="kw">dyn </span>std::error::Error>>(())</code></pre></div>
|
|||
|
|
<p>And now we show the behavior when we only include implicit capture
|
|||
|
|
groups. In this case, we can only find the overall match span, but the
|
|||
|
|
spans of any other explicit group don’t exist because they are treated
|
|||
|
|
as non-capturing. (In effect, when <code>WhichCaptures::Implicit</code> is used,
|
|||
|
|
there is no real point in using <a href="struct.Regex.html#method.captures" title="method regex_automata::meta::Regex::captures"><code>Regex::captures</code></a> since it will never
|
|||
|
|
be able to report more information than <a href="struct.Regex.html#method.find" title="method regex_automata::meta::Regex::find"><code>Regex::find</code></a>.)</p>
|
|||
|
|
|
|||
|
|
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use </span>regex_automata::{
|
|||
|
|
meta::Regex,
|
|||
|
|
nfa::thompson::WhichCaptures,
|
|||
|
|
Match,
|
|||
|
|
Span,
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
<span class="kw">let </span>re = Regex::builder()
|
|||
|
|
.configure(Regex::config().which_captures(WhichCaptures::Implicit))
|
|||
|
|
.build(<span class="string">r"foo([0-9]+)bar"</span>)<span class="question-mark">?</span>;
|
|||
|
|
<span class="kw">let </span>hay = <span class="string">"foo123bar"</span>;
|
|||
|
|
|
|||
|
|
<span class="kw">let </span><span class="kw-2">mut </span>caps = re.create_captures();
|
|||
|
|
re.captures(hay, <span class="kw-2">&mut </span>caps);
|
|||
|
|
<span class="macro">assert_eq!</span>(<span class="prelude-val">Some</span>(Span::from(<span class="number">0</span>..<span class="number">9</span>)), caps.get_group(<span class="number">0</span>));
|
|||
|
|
<span class="macro">assert_eq!</span>(<span class="prelude-val">None</span>, caps.get_group(<span class="number">1</span>));
|
|||
|
|
|
|||
|
|
<span class="prelude-val">Ok</span>::<(), Box<<span class="kw">dyn </span>std::error::Error>>(())</code></pre></div>
|
|||
|
|
</div></details><details class="toggle method-toggle" open><summary><section id="method.nfa_size_limit" class="method"><a class="src rightside" href="../../src/regex_automata/meta/regex.rs.html#2752-2754">source</a><h4 class="code-header">pub fn <a href="#method.nfa_size_limit" class="fn">nfa_size_limit</a>(self, limit: <a class="enum" href="https://doc.rust-lang.org/1.76.0/core/option/enum.Option.html" title="enum core::option::Option">Option</a><<a class="primitive" href="https://doc.rust-lang.org/1.76.0/std/primitive.usize.html">usize</a>>) -> <a class="struct" href="struct.Config.html" title="struct regex_automata::meta::Config">Config</a></h4></section></summary><div class="docblock"><p>Sets the size limit, in bytes, to enforce on the construction of every
|
|||
|
|
NFA build by the meta regex engine.</p>
|
|||
|
|
<p>Setting it to <code>None</code> disables the limit. This is not recommended if
|
|||
|
|
you’re compiling untrusted patterns.</p>
|
|||
|
|
<p>Note that this limit is applied to <em>each</em> NFA built, and if any of
|
|||
|
|
them exceed the limit, then construction will fail. This limit does
|
|||
|
|
<em>not</em> correspond to the total memory used by all NFAs in the meta regex
|
|||
|
|
engine.</p>
|
|||
|
|
<p>This defaults to some reasonable number that permits most reasonable
|
|||
|
|
patterns.</p>
|
|||
|
|
<h5 id="example-5"><a href="#example-5">Example</a></h5>
|
|||
|
|
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use </span>regex_automata::meta::Regex;
|
|||
|
|
|
|||
|
|
<span class="kw">let </span>result = Regex::builder()
|
|||
|
|
.configure(Regex::config().nfa_size_limit(<span class="prelude-val">Some</span>(<span class="number">20 </span>* (<span class="number">1</span><<<span class="number">10</span>))))
|
|||
|
|
<span class="comment">// Not even 20KB is enough to build a single large Unicode class!
|
|||
|
|
</span>.build(<span class="string">r"\pL"</span>);
|
|||
|
|
<span class="macro">assert!</span>(result.is_err());
|
|||
|
|
|
|||
|
|
<span class="comment">// But notice that building such a regex with the exact same limit
|
|||
|
|
// can succeed depending on other aspects of the configuration. For
|
|||
|
|
// example, a single *forward* NFA will (at time of writing) fit into
|
|||
|
|
// the 20KB limit, but a *reverse* NFA of the same pattern will not.
|
|||
|
|
// So if one configures a meta regex such that a reverse NFA is never
|
|||
|
|
// needed and thus never built, then the 20KB limit will be enough for
|
|||
|
|
// a pattern like \pL!
|
|||
|
|
</span><span class="kw">let </span>result = Regex::builder()
|
|||
|
|
.configure(Regex::config()
|
|||
|
|
.nfa_size_limit(<span class="prelude-val">Some</span>(<span class="number">20 </span>* (<span class="number">1</span><<<span class="number">10</span>)))
|
|||
|
|
<span class="comment">// The DFAs are the only thing that (currently) need a reverse
|
|||
|
|
// NFA. So if both are disabled, the meta regex engine will
|
|||
|
|
// skip building the reverse NFA. Note that this isn't an API
|
|||
|
|
// guarantee. A future semver compatible version may introduce
|
|||
|
|
// new use cases for a reverse NFA.
|
|||
|
|
</span>.hybrid(<span class="bool-val">false</span>)
|
|||
|
|
.dfa(<span class="bool-val">false</span>)
|
|||
|
|
)
|
|||
|
|
<span class="comment">// Not even 20KB is enough to build a single large Unicode class!
|
|||
|
|
</span>.build(<span class="string">r"\pL"</span>);
|
|||
|
|
<span class="macro">assert!</span>(result.is_ok());
|
|||
|
|
</code></pre></div>
|
|||
|
|
</div></details><details class="toggle method-toggle" open><summary><section id="method.onepass_size_limit" class="method"><a class="src rightside" href="../../src/regex_automata/meta/regex.rs.html#2784-2786">source</a><h4 class="code-header">pub fn <a href="#method.onepass_size_limit" class="fn">onepass_size_limit</a>(self, limit: <a class="enum" href="https://doc.rust-lang.org/1.76.0/core/option/enum.Option.html" title="enum core::option::Option">Option</a><<a class="primitive" href="https://doc.rust-lang.org/1.76.0/std/primitive.usize.html">usize</a>>) -> <a class="struct" href="struct.Config.html" title="struct regex_automata::meta::Config">Config</a></h4></section></summary><div class="docblock"><p>Sets the size limit, in bytes, for the one-pass DFA.</p>
|
|||
|
|
<p>Setting it to <code>None</code> disables the limit. Disabling the limit is
|
|||
|
|
strongly discouraged when compiling untrusted patterns. Even if the
|
|||
|
|
patterns are trusted, it still may not be a good idea, since a one-pass
|
|||
|
|
DFA can use a lot of memory. With that said, as the size of a regex
|
|||
|
|
increases, the likelihood of it being one-pass likely decreases.</p>
|
|||
|
|
<p>This defaults to some reasonable number that permits most reasonable
|
|||
|
|
one-pass patterns.</p>
|
|||
|
|
<h5 id="example-6"><a href="#example-6">Example</a></h5>
|
|||
|
|
<p>This shows how to set the one-pass DFA size limit. Note that since
|
|||
|
|
a one-pass DFA is an optional component of the meta regex engine,
|
|||
|
|
this size limit only impacts what is built internally and will never
|
|||
|
|
determine whether a <code>Regex</code> itself fails to build.</p>
|
|||
|
|
|
|||
|
|
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use </span>regex_automata::meta::Regex;
|
|||
|
|
|
|||
|
|
<span class="kw">let </span>result = Regex::builder()
|
|||
|
|
.configure(Regex::config().onepass_size_limit(<span class="prelude-val">Some</span>(<span class="number">2 </span>* (<span class="number">1</span><<<span class="number">20</span>))))
|
|||
|
|
.build(<span class="string">r"\pL{5}"</span>);
|
|||
|
|
<span class="macro">assert!</span>(result.is_ok());</code></pre></div>
|
|||
|
|
</div></details><details class="toggle method-toggle" open><summary><section id="method.hybrid_cache_capacity" class="method"><a class="src rightside" href="../../src/regex_automata/meta/regex.rs.html#2826-2828">source</a><h4 class="code-header">pub fn <a href="#method.hybrid_cache_capacity" class="fn">hybrid_cache_capacity</a>(self, limit: <a class="primitive" href="https://doc.rust-lang.org/1.76.0/std/primitive.usize.html">usize</a>) -> <a class="struct" href="struct.Config.html" title="struct regex_automata::meta::Config">Config</a></h4></section></summary><div class="docblock"><p>Set the cache capacity, in bytes, for the lazy DFA.</p>
|
|||
|
|
<p>The cache capacity of the lazy DFA determines approximately how much
|
|||
|
|
heap memory it is allowed to use to store its state transitions. The
|
|||
|
|
state transitions are computed at search time, and if the cache fills
|
|||
|
|
up it, it is cleared. At this point, any previously generated state
|
|||
|
|
transitions are lost and are re-generated if they’re needed again.</p>
|
|||
|
|
<p>This sort of cache filling and clearing works quite well <em>so long as
|
|||
|
|
cache clearing happens infrequently</em>. If it happens too often, then the
|
|||
|
|
meta regex engine will stop using the lazy DFA and switch over to a
|
|||
|
|
different regex engine.</p>
|
|||
|
|
<p>In cases where the cache is cleared too often, it may be possible to
|
|||
|
|
give the cache more space and reduce (or eliminate) how often it is
|
|||
|
|
cleared. Similarly, sometimes a regex is so big that the lazy DFA isn’t
|
|||
|
|
used at all if its cache capacity isn’t big enough.</p>
|
|||
|
|
<p>The capacity set here is a <em>limit</em> on how much memory is used. The
|
|||
|
|
actual memory used is only allocated as it’s needed.</p>
|
|||
|
|
<p>Determining the right value for this is a little tricky and will likely
|
|||
|
|
required some profiling. Enabling the <code>logging</code> feature and setting the
|
|||
|
|
log level to <code>trace</code> will also tell you how often the cache is being
|
|||
|
|
cleared.</p>
|
|||
|
|
<h5 id="example-7"><a href="#example-7">Example</a></h5>
|
|||
|
|
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use </span>regex_automata::meta::Regex;
|
|||
|
|
|
|||
|
|
<span class="kw">let </span>result = Regex::builder()
|
|||
|
|
.configure(Regex::config().hybrid_cache_capacity(<span class="number">20 </span>* (<span class="number">1</span><<<span class="number">20</span>)))
|
|||
|
|
.build(<span class="string">r"\pL{5}"</span>);
|
|||
|
|
<span class="macro">assert!</span>(result.is_ok());</code></pre></div>
|
|||
|
|
</div></details><details class="toggle method-toggle" open><summary><section id="method.dfa_size_limit" class="method"><a class="src rightside" href="../../src/regex_automata/meta/regex.rs.html#2875-2877">source</a><h4 class="code-header">pub fn <a href="#method.dfa_size_limit" class="fn">dfa_size_limit</a>(self, limit: <a class="enum" href="https://doc.rust-lang.org/1.76.0/core/option/enum.Option.html" title="enum core::option::Option">Option</a><<a class="primitive" href="https://doc.rust-lang.org/1.76.0/std/primitive.usize.html">usize</a>>) -> <a class="struct" href="struct.Config.html" title="struct regex_automata::meta::Config">Config</a></h4></section></summary><div class="docblock"><p>Sets the size limit, in bytes, for heap memory used for a fully
|
|||
|
|
compiled DFA.</p>
|
|||
|
|
<p><strong>NOTE:</strong> If you increase this, you’ll likely also need to increase
|
|||
|
|
<a href="struct.Config.html#method.dfa_state_limit" title="method regex_automata::meta::Config::dfa_state_limit"><code>Config::dfa_state_limit</code></a>.</p>
|
|||
|
|
<p>In contrast to the lazy DFA, building a full DFA requires computing
|
|||
|
|
all of its state transitions up front. This can be a very expensive
|
|||
|
|
process, and runs in worst case <code>2^n</code> time and space (where <code>n</code> is
|
|||
|
|
proportional to the size of the regex). However, a full DFA unlocks
|
|||
|
|
some additional optimization opportunities.</p>
|
|||
|
|
<p>Because full DFAs can be so expensive, the default limits for them are
|
|||
|
|
incredibly small. Generally speaking, if your regex is moderately big
|
|||
|
|
or if you’re using Unicode features (<code>\w</code> is Unicode-aware by default
|
|||
|
|
for example), then you can expect that the meta regex engine won’t even
|
|||
|
|
attempt to build a DFA for it.</p>
|
|||
|
|
<p>If this and <a href="struct.Config.html#method.dfa_state_limit" title="method regex_automata::meta::Config::dfa_state_limit"><code>Config::dfa_state_limit</code></a> are set to <code>None</code>, then the
|
|||
|
|
meta regex will not use any sort of limits when deciding whether to
|
|||
|
|
build a DFA. This in turn makes construction of a <code>Regex</code> take
|
|||
|
|
worst case exponential time and space. Even short patterns can result
|
|||
|
|
in huge space blow ups. So it is strongly recommended to keep some kind
|
|||
|
|
of limit set!</p>
|
|||
|
|
<p>The default is set to a small number that permits some simple regexes
|
|||
|
|
to get compiled into DFAs in reasonable time.</p>
|
|||
|
|
<h5 id="example-8"><a href="#example-8">Example</a></h5>
|
|||
|
|
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use </span>regex_automata::meta::Regex;
|
|||
|
|
|
|||
|
|
<span class="kw">let </span>result = Regex::builder()
|
|||
|
|
<span class="comment">// 100MB is much bigger than the default.
|
|||
|
|
</span>.configure(Regex::config()
|
|||
|
|
.dfa_size_limit(<span class="prelude-val">Some</span>(<span class="number">100 </span>* (<span class="number">1</span><<<span class="number">20</span>)))
|
|||
|
|
<span class="comment">// We don't care about size too much here, so just
|
|||
|
|
// remove the NFA state limit altogether.
|
|||
|
|
</span>.dfa_state_limit(<span class="prelude-val">None</span>))
|
|||
|
|
.build(<span class="string">r"\pL{5}"</span>);
|
|||
|
|
<span class="macro">assert!</span>(result.is_ok());</code></pre></div>
|
|||
|
|
</div></details><details class="toggle method-toggle" open><summary><section id="method.dfa_state_limit" class="method"><a class="src rightside" href="../../src/regex_automata/meta/regex.rs.html#2907-2909">source</a><h4 class="code-header">pub fn <a href="#method.dfa_state_limit" class="fn">dfa_state_limit</a>(self, limit: <a class="enum" href="https://doc.rust-lang.org/1.76.0/core/option/enum.Option.html" title="enum core::option::Option">Option</a><<a class="primitive" href="https://doc.rust-lang.org/1.76.0/std/primitive.usize.html">usize</a>>) -> <a class="struct" href="struct.Config.html" title="struct regex_automata::meta::Config">Config</a></h4></section></summary><div class="docblock"><p>Sets a limit on the total number of NFA states, beyond which, a full
|
|||
|
|
DFA is not attempted to be compiled.</p>
|
|||
|
|
<p>This limit works in concert with <a href="struct.Config.html#method.dfa_size_limit" title="method regex_automata::meta::Config::dfa_size_limit"><code>Config::dfa_size_limit</code></a>. Namely,
|
|||
|
|
where as <code>Config::dfa_size_limit</code> is applied by attempting to construct
|
|||
|
|
a DFA, this limit is used to avoid the attempt in the first place. This
|
|||
|
|
is useful to avoid hefty initialization costs associated with building
|
|||
|
|
a DFA for cases where it is obvious the DFA will ultimately be too big.</p>
|
|||
|
|
<p>By default, this is set to a very small number.</p>
|
|||
|
|
<h5 id="example-9"><a href="#example-9">Example</a></h5>
|
|||
|
|
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use </span>regex_automata::meta::Regex;
|
|||
|
|
|
|||
|
|
<span class="kw">let </span>result = Regex::builder()
|
|||
|
|
.configure(Regex::config()
|
|||
|
|
<span class="comment">// Sometimes the default state limit rejects DFAs even
|
|||
|
|
// if they would fit in the size limit. Here, we disable
|
|||
|
|
// the check on the number of NFA states and just rely on
|
|||
|
|
// the size limit.
|
|||
|
|
</span>.dfa_state_limit(<span class="prelude-val">None</span>))
|
|||
|
|
.build(<span class="string">r"(?-u)\w{30}"</span>);
|
|||
|
|
<span class="macro">assert!</span>(result.is_ok());</code></pre></div>
|
|||
|
|
</div></details><details class="toggle method-toggle" open><summary><section id="method.byte_classes" class="method"><a class="src rightside" href="../../src/regex_automata/meta/regex.rs.html#2938-2940">source</a><h4 class="code-header">pub fn <a href="#method.byte_classes" class="fn">byte_classes</a>(self, yes: <a class="primitive" href="https://doc.rust-lang.org/1.76.0/std/primitive.bool.html">bool</a>) -> <a class="struct" href="struct.Config.html" title="struct regex_automata::meta::Config">Config</a></h4></section></summary><div class="docblock"><p>Whether to attempt to shrink the size of the alphabet for the regex
|
|||
|
|
pattern or not. When enabled, the alphabet is shrunk into a set of
|
|||
|
|
equivalence classes, where every byte in the same equivalence class
|
|||
|
|
cannot discriminate between a match or non-match.</p>
|
|||
|
|
<p><strong>WARNING:</strong> This is only useful for debugging DFAs. Disabling this
|
|||
|
|
does not yield any speed advantages. Indeed, disabling it can result
|
|||
|
|
in much higher memory usage. Disabling byte classes is useful for
|
|||
|
|
debugging the actual generated transitions because it lets one see the
|
|||
|
|
transitions defined on actual bytes instead of the equivalence classes.</p>
|
|||
|
|
<p>This option is enabled by default and should never be disabled unless
|
|||
|
|
one is debugging the meta regex engine’s internals.</p>
|
|||
|
|
<h5 id="example-10"><a href="#example-10">Example</a></h5>
|
|||
|
|
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use </span>regex_automata::{meta::Regex, Match};
|
|||
|
|
|
|||
|
|
<span class="kw">let </span>re = Regex::builder()
|
|||
|
|
.configure(Regex::config().byte_classes(<span class="bool-val">false</span>))
|
|||
|
|
.build(<span class="string">r"[a-z]+"</span>)<span class="question-mark">?</span>;
|
|||
|
|
<span class="kw">let </span>hay = <span class="string">"!!quux!!"</span>;
|
|||
|
|
<span class="macro">assert_eq!</span>(<span class="prelude-val">Some</span>(Match::must(<span class="number">0</span>, <span class="number">2</span>..<span class="number">6</span>)), re.find(hay));
|
|||
|
|
</code></pre></div>
|
|||
|
|
</div></details><details class="toggle method-toggle" open><summary><section id="method.line_terminator" class="method"><a class="src rightside" href="../../src/regex_automata/meta/regex.rs.html#2972-2974">source</a><h4 class="code-header">pub fn <a href="#method.line_terminator" class="fn">line_terminator</a>(self, byte: <a class="primitive" href="https://doc.rust-lang.org/1.76.0/std/primitive.u8.html">u8</a>) -> <a class="struct" href="struct.Config.html" title="struct regex_automata::meta::Config">Config</a></h4></section></summary><div class="docblock"><p>Set the line terminator to be used by the <code>^</code> and <code>$</code> anchors in
|
|||
|
|
multi-line mode.</p>
|
|||
|
|
<p>This option has no effect when CRLF mode is enabled. That is,
|
|||
|
|
regardless of this setting, <code>(?Rm:^)</code> and <code>(?Rm:$)</code> will always treat
|
|||
|
|
<code>\r</code> and <code>\n</code> as line terminators (and will never match between a <code>\r</code>
|
|||
|
|
and a <code>\n</code>).</p>
|
|||
|
|
<p>By default, <code>\n</code> is the line terminator.</p>
|
|||
|
|
<p><strong>Warning</strong>: This does not change the behavior of <code>.</code>. To do that,
|
|||
|
|
you’ll need to configure the syntax option
|
|||
|
|
<a href="../util/syntax/struct.Config.html#method.line_terminator" title="method regex_automata::util::syntax::Config::line_terminator"><code>syntax::Config::line_terminator</code></a>
|
|||
|
|
in addition to this. Otherwise, <code>.</code> will continue to match any
|
|||
|
|
character other than <code>\n</code>.</p>
|
|||
|
|
<h5 id="example-11"><a href="#example-11">Example</a></h5>
|
|||
|
|
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use </span>regex_automata::{meta::Regex, util::syntax, Match};
|
|||
|
|
|
|||
|
|
<span class="kw">let </span>re = Regex::builder()
|
|||
|
|
.syntax(syntax::Config::new().multi_line(<span class="bool-val">true</span>))
|
|||
|
|
.configure(Regex::config().line_terminator(<span class="string">b'\x00'</span>))
|
|||
|
|
.build(<span class="string">r"^foo$"</span>)<span class="question-mark">?</span>;
|
|||
|
|
<span class="kw">let </span>hay = <span class="string">"\x00foo\x00"</span>;
|
|||
|
|
<span class="macro">assert_eq!</span>(<span class="prelude-val">Some</span>(Match::must(<span class="number">0</span>, <span class="number">1</span>..<span class="number">4</span>)), re.find(hay));
|
|||
|
|
</code></pre></div>
|
|||
|
|
</div></details><details class="toggle method-toggle" open><summary><section id="method.hybrid" class="method"><a class="src rightside" href="../../src/regex_automata/meta/regex.rs.html#2986-2988">source</a><h4 class="code-header">pub fn <a href="#method.hybrid" class="fn">hybrid</a>(self, yes: <a class="primitive" href="https://doc.rust-lang.org/1.76.0/std/primitive.bool.html">bool</a>) -> <a class="struct" href="struct.Config.html" title="struct regex_automata::meta::Config">Config</a></h4></section></summary><div class="docblock"><p>Toggle whether the hybrid NFA/DFA (also known as the “lazy DFA”) should
|
|||
|
|
be available for use by the meta regex engine.</p>
|
|||
|
|
<p>Enabling this does not necessarily mean that the lazy DFA will
|
|||
|
|
definitely be used. It just means that it will be <em>available</em> for use
|
|||
|
|
if the meta regex engine thinks it will be useful.</p>
|
|||
|
|
<p>When the <code>hybrid</code> crate feature is enabled, then this is enabled by
|
|||
|
|
default. Otherwise, if the crate feature is disabled, then this is
|
|||
|
|
always disabled, regardless of its setting by the caller.</p>
|
|||
|
|
</div></details><details class="toggle method-toggle" open><summary><section id="method.dfa" class="method"><a class="src rightside" href="../../src/regex_automata/meta/regex.rs.html#3000-3002">source</a><h4 class="code-header">pub fn <a href="#method.dfa" class="fn">dfa</a>(self, yes: <a class="primitive" href="https://doc.rust-lang.org/1.76.0/std/primitive.bool.html">bool</a>) -> <a class="struct" href="struct.Config.html" title="struct regex_automata::meta::Config">Config</a></h4></section></summary><div class="docblock"><p>Toggle whether a fully compiled DFA should be available for use by the
|
|||
|
|
meta regex engine.</p>
|
|||
|
|
<p>Enabling this does not necessarily mean that a DFA will definitely be
|
|||
|
|
used. It just means that it will be <em>available</em> for use if the meta
|
|||
|
|
regex engine thinks it will be useful.</p>
|
|||
|
|
<p>When the <code>dfa-build</code> crate feature is enabled, then this is enabled by
|
|||
|
|
default. Otherwise, if the crate feature is disabled, then this is
|
|||
|
|
always disabled, regardless of its setting by the caller.</p>
|
|||
|
|
</div></details><details class="toggle method-toggle" open><summary><section id="method.onepass" class="method"><a class="src rightside" href="../../src/regex_automata/meta/regex.rs.html#3016-3018">source</a><h4 class="code-header">pub fn <a href="#method.onepass" class="fn">onepass</a>(self, yes: <a class="primitive" href="https://doc.rust-lang.org/1.76.0/std/primitive.bool.html">bool</a>) -> <a class="struct" href="struct.Config.html" title="struct regex_automata::meta::Config">Config</a></h4></section></summary><div class="docblock"><p>Toggle whether a one-pass DFA should be available for use by the meta
|
|||
|
|
regex engine.</p>
|
|||
|
|
<p>Enabling this does not necessarily mean that a one-pass DFA will
|
|||
|
|
definitely be used. It just means that it will be <em>available</em> for
|
|||
|
|
use if the meta regex engine thinks it will be useful. (Indeed, a
|
|||
|
|
one-pass DFA can only be used when the regex is one-pass. See the
|
|||
|
|
<a href="crate::dfa::onepass"><code>dfa::onepass</code></a> module for more details.)</p>
|
|||
|
|
<p>When the <code>dfa-onepass</code> crate feature is enabled, then this is enabled
|
|||
|
|
by default. Otherwise, if the crate feature is disabled, then this is
|
|||
|
|
always disabled, regardless of its setting by the caller.</p>
|
|||
|
|
</div></details><details class="toggle method-toggle" open><summary><section id="method.backtrack" class="method"><a class="src rightside" href="../../src/regex_automata/meta/regex.rs.html#3030-3032">source</a><h4 class="code-header">pub fn <a href="#method.backtrack" class="fn">backtrack</a>(self, yes: <a class="primitive" href="https://doc.rust-lang.org/1.76.0/std/primitive.bool.html">bool</a>) -> <a class="struct" href="struct.Config.html" title="struct regex_automata::meta::Config">Config</a></h4></section></summary><div class="docblock"><p>Toggle whether a bounded backtracking regex engine should be available
|
|||
|
|
for use by the meta regex engine.</p>
|
|||
|
|
<p>Enabling this does not necessarily mean that a bounded backtracker will
|
|||
|
|
definitely be used. It just means that it will be <em>available</em> for use
|
|||
|
|
if the meta regex engine thinks it will be useful.</p>
|
|||
|
|
<p>When the <code>nfa-backtrack</code> crate feature is enabled, then this is enabled
|
|||
|
|
by default. Otherwise, if the crate feature is disabled, then this is
|
|||
|
|
always disabled, regardless of its setting by the caller.</p>
|
|||
|
|
</div></details><details class="toggle method-toggle" open><summary><section id="method.get_match_kind" class="method"><a class="src rightside" href="../../src/regex_automata/meta/regex.rs.html#3038-3040">source</a><h4 class="code-header">pub fn <a href="#method.get_match_kind" class="fn">get_match_kind</a>(&self) -> <a class="enum" href="../enum.MatchKind.html" title="enum regex_automata::MatchKind">MatchKind</a></h4></section></summary><div class="docblock"><p>Returns the match kind on this configuration, as set by
|
|||
|
|
<a href="struct.Config.html#method.match_kind" title="method regex_automata::meta::Config::match_kind"><code>Config::match_kind</code></a>.</p>
|
|||
|
|
<p>If it was not explicitly set, then a default value is returned.</p>
|
|||
|
|
</div></details><details class="toggle method-toggle" open><summary><section id="method.get_utf8_empty" class="method"><a class="src rightside" href="../../src/regex_automata/meta/regex.rs.html#3046-3048">source</a><h4 class="code-header">pub fn <a href="#method.get_utf8_empty" class="fn">get_utf8_empty</a>(&self) -> <a class="primitive" href="https://doc.rust-lang.org/1.76.0/std/primitive.bool.html">bool</a></h4></section></summary><div class="docblock"><p>Returns whether empty matches must fall on valid UTF-8 boundaries, as
|
|||
|
|
set by <a href="struct.Config.html#method.utf8_empty" title="method regex_automata::meta::Config::utf8_empty"><code>Config::utf8_empty</code></a>.</p>
|
|||
|
|
<p>If it was not explicitly set, then a default value is returned.</p>
|
|||
|
|
</div></details><details class="toggle method-toggle" open><summary><section id="method.get_auto_prefilter" class="method"><a class="src rightside" href="../../src/regex_automata/meta/regex.rs.html#3054-3056">source</a><h4 class="code-header">pub fn <a href="#method.get_auto_prefilter" class="fn">get_auto_prefilter</a>(&self) -> <a class="primitive" href="https://doc.rust-lang.org/1.76.0/std/primitive.bool.html">bool</a></h4></section></summary><div class="docblock"><p>Returns whether automatic prefilters are enabled, as set by
|
|||
|
|
<a href="struct.Config.html#method.auto_prefilter" title="method regex_automata::meta::Config::auto_prefilter"><code>Config::auto_prefilter</code></a>.</p>
|
|||
|
|
<p>If it was not explicitly set, then a default value is returned.</p>
|
|||
|
|
</div></details><details class="toggle method-toggle" open><summary><section id="method.get_prefilter" class="method"><a class="src rightside" href="../../src/regex_automata/meta/regex.rs.html#3062-3064">source</a><h4 class="code-header">pub fn <a href="#method.get_prefilter" class="fn">get_prefilter</a>(&self) -> <a class="enum" href="https://doc.rust-lang.org/1.76.0/core/option/enum.Option.html" title="enum core::option::Option">Option</a><&<a class="struct" href="../util/prefilter/struct.Prefilter.html" title="struct regex_automata::util::prefilter::Prefilter">Prefilter</a>></h4></section></summary><div class="docblock"><p>Returns a manually set prefilter, if one was set by
|
|||
|
|
<a href="struct.Config.html#method.prefilter" title="method regex_automata::meta::Config::prefilter"><code>Config::prefilter</code></a>.</p>
|
|||
|
|
<p>If it was not explicitly set, then a default value is returned.</p>
|
|||
|
|
</div></details><details class="toggle method-toggle" open><summary><section id="method.get_which_captures" class="method"><a class="src rightside" href="../../src/regex_automata/meta/regex.rs.html#3070-3072">source</a><h4 class="code-header">pub fn <a href="#method.get_which_captures" class="fn">get_which_captures</a>(&self) -> <a class="enum" href="../nfa/thompson/enum.WhichCaptures.html" title="enum regex_automata::nfa::thompson::WhichCaptures">WhichCaptures</a></h4></section></summary><div class="docblock"><p>Returns the capture configuration, as set by
|
|||
|
|
<a href="struct.Config.html#method.which_captures" title="method regex_automata::meta::Config::which_captures"><code>Config::which_captures</code></a>.</p>
|
|||
|
|
<p>If it was not explicitly set, then a default value is returned.</p>
|
|||
|
|
</div></details><details class="toggle method-toggle" open><summary><section id="method.get_nfa_size_limit" class="method"><a class="src rightside" href="../../src/regex_automata/meta/regex.rs.html#3077-3079">source</a><h4 class="code-header">pub fn <a href="#method.get_nfa_size_limit" class="fn">get_nfa_size_limit</a>(&self) -> <a class="enum" href="https://doc.rust-lang.org/1.76.0/core/option/enum.Option.html" title="enum core::option::Option">Option</a><<a class="primitive" href="https://doc.rust-lang.org/1.76.0/std/primitive.usize.html">usize</a>></h4></section></summary><div class="docblock"><p>Returns NFA size limit, as set by <a href="struct.Config.html#method.nfa_size_limit" title="method regex_automata::meta::Config::nfa_size_limit"><code>Config::nfa_size_limit</code></a>.</p>
|
|||
|
|
<p>If it was not explicitly set, then a default value is returned.</p>
|
|||
|
|
</div></details><details class="toggle method-toggle" open><summary><section id="method.get_onepass_size_limit" class="method"><a class="src rightside" href="../../src/regex_automata/meta/regex.rs.html#3085-3087">source</a><h4 class="code-header">pub fn <a href="#method.get_onepass_size_limit" class="fn">get_onepass_size_limit</a>(&self) -> <a class="enum" href="https://doc.rust-lang.org/1.76.0/core/option/enum.Option.html" title="enum core::option::Option">Option</a><<a class="primitive" href="https://doc.rust-lang.org/1.76.0/std/primitive.usize.html">usize</a>></h4></section></summary><div class="docblock"><p>Returns one-pass DFA size limit, as set by
|
|||
|
|
<a href="struct.Config.html#method.onepass_size_limit" title="method regex_automata::meta::Config::onepass_size_limit"><code>Config::onepass_size_limit</code></a>.</p>
|
|||
|
|
<p>If it was not explicitly set, then a default value is returned.</p>
|
|||
|
|
</div></details><details class="toggle method-toggle" open><summary><section id="method.get_hybrid_cache_capacity" class="method"><a class="src rightside" href="../../src/regex_automata/meta/regex.rs.html#3093-3095">source</a><h4 class="code-header">pub fn <a href="#method.get_hybrid_cache_capacity" class="fn">get_hybrid_cache_capacity</a>(&self) -> <a class="primitive" href="https://doc.rust-lang.org/1.76.0/std/primitive.usize.html">usize</a></h4></section></summary><div class="docblock"><p>Returns hybrid NFA/DFA cache capacity, as set by
|
|||
|
|
<a href="struct.Config.html#method.hybrid_cache_capacity" title="method regex_automata::meta::Config::hybrid_cache_capacity"><code>Config::hybrid_cache_capacity</code></a>.</p>
|
|||
|
|
<p>If it was not explicitly set, then a default value is returned.</p>
|
|||
|
|
</div></details><details class="toggle method-toggle" open><summary><section id="method.get_dfa_size_limit" class="method"><a class="src rightside" href="../../src/regex_automata/meta/regex.rs.html#3100-3120">source</a><h4 class="code-header">pub fn <a href="#method.get_dfa_size_limit" class="fn">get_dfa_size_limit</a>(&self) -> <a class="enum" href="https://doc.rust-lang.org/1.76.0/core/option/enum.Option.html" title="enum core::option::Option">Option</a><<a class="primitive" href="https://doc.rust-lang.org/1.76.0/std/primitive.usize.html">usize</a>></h4></section></summary><div class="docblock"><p>Returns DFA size limit, as set by <a href="struct.Config.html#method.dfa_size_limit" title="method regex_automata::meta::Config::dfa_size_limit"><code>Config::dfa_size_limit</code></a>.</p>
|
|||
|
|
<p>If it was not explicitly set, then a default value is returned.</p>
|
|||
|
|
</div></details><details class="toggle method-toggle" open><summary><section id="method.get_dfa_state_limit" class="method"><a class="src rightside" href="../../src/regex_automata/meta/regex.rs.html#3126-3129">source</a><h4 class="code-header">pub fn <a href="#method.get_dfa_state_limit" class="fn">get_dfa_state_limit</a>(&self) -> <a class="enum" href="https://doc.rust-lang.org/1.76.0/core/option/enum.Option.html" title="enum core::option::Option">Option</a><<a class="primitive" href="https://doc.rust-lang.org/1.76.0/std/primitive.usize.html">usize</a>></h4></section></summary><div class="docblock"><p>Returns DFA size limit in terms of the number of states in the NFA, as
|
|||
|
|
set by <a href="struct.Config.html#method.dfa_state_limit" title="method regex_automata::meta::Config::dfa_state_limit"><code>Config::dfa_state_limit</code></a>.</p>
|
|||
|
|
<p>If it was not explicitly set, then a default value is returned.</p>
|
|||
|
|
</div></details><details class="toggle method-toggle" open><summary><section id="method.get_byte_classes" class="method"><a class="src rightside" href="../../src/regex_automata/meta/regex.rs.html#3135-3137">source</a><h4 class="code-header">pub fn <a href="#method.get_byte_classes" class="fn">get_byte_classes</a>(&self) -> <a class="primitive" href="https://doc.rust-lang.org/1.76.0/std/primitive.bool.html">bool</a></h4></section></summary><div class="docblock"><p>Returns whether byte classes are enabled, as set by
|
|||
|
|
<a href="struct.Config.html#method.byte_classes" title="method regex_automata::meta::Config::byte_classes"><code>Config::byte_classes</code></a>.</p>
|
|||
|
|
<p>If it was not explicitly set, then a default value is returned.</p>
|
|||
|
|
</div></details><details class="toggle method-toggle" open><summary><section id="method.get_line_terminator" class="method"><a class="src rightside" href="../../src/regex_automata/meta/regex.rs.html#3143-3145">source</a><h4 class="code-header">pub fn <a href="#method.get_line_terminator" class="fn">get_line_terminator</a>(&self) -> <a class="primitive" href="https://doc.rust-lang.org/1.76.0/std/primitive.u8.html">u8</a></h4></section></summary><div class="docblock"><p>Returns the line terminator for this configuration, as set by
|
|||
|
|
<a href="struct.Config.html#method.line_terminator" title="method regex_automata::meta::Config::line_terminator"><code>Config::line_terminator</code></a>.</p>
|
|||
|
|
<p>If it was not explicitly set, then a default value is returned.</p>
|
|||
|
|
</div></details><details class="toggle method-toggle" open><summary><section id="method.get_hybrid" class="method"><a class="src rightside" href="../../src/regex_automata/meta/regex.rs.html#3151-3160">source</a><h4 class="code-header">pub fn <a href="#method.get_hybrid" class="fn">get_hybrid</a>(&self) -> <a class="primitive" href="https://doc.rust-lang.org/1.76.0/std/primitive.bool.html">bool</a></h4></section></summary><div class="docblock"><p>Returns whether the hybrid NFA/DFA regex engine may be used, as set by
|
|||
|
|
<a href="struct.Config.html#method.hybrid" title="method regex_automata::meta::Config::hybrid"><code>Config::hybrid</code></a>.</p>
|
|||
|
|
<p>If it was not explicitly set, then a default value is returned.</p>
|
|||
|
|
</div></details><details class="toggle method-toggle" open><summary><section id="method.get_dfa" class="method"><a class="src rightside" href="../../src/regex_automata/meta/regex.rs.html#3166-3175">source</a><h4 class="code-header">pub fn <a href="#method.get_dfa" class="fn">get_dfa</a>(&self) -> <a class="primitive" href="https://doc.rust-lang.org/1.76.0/std/primitive.bool.html">bool</a></h4></section></summary><div class="docblock"><p>Returns whether the DFA regex engine may be used, as set by
|
|||
|
|
<a href="struct.Config.html#method.dfa" title="method regex_automata::meta::Config::dfa"><code>Config::dfa</code></a>.</p>
|
|||
|
|
<p>If it was not explicitly set, then a default value is returned.</p>
|
|||
|
|
</div></details><details class="toggle method-toggle" open><summary><section id="method.get_onepass" class="method"><a class="src rightside" href="../../src/regex_automata/meta/regex.rs.html#3181-3190">source</a><h4 class="code-header">pub fn <a href="#method.get_onepass" class="fn">get_onepass</a>(&self) -> <a class="primitive" href="https://doc.rust-lang.org/1.76.0/std/primitive.bool.html">bool</a></h4></section></summary><div class="docblock"><p>Returns whether the one-pass DFA regex engine may be used, as set by
|
|||
|
|
<a href="struct.Config.html#method.onepass" title="method regex_automata::meta::Config::onepass"><code>Config::onepass</code></a>.</p>
|
|||
|
|
<p>If it was not explicitly set, then a default value is returned.</p>
|
|||
|
|
</div></details><details class="toggle method-toggle" open><summary><section id="method.get_backtrack" class="method"><a class="src rightside" href="../../src/regex_automata/meta/regex.rs.html#3196-3205">source</a><h4 class="code-header">pub fn <a href="#method.get_backtrack" class="fn">get_backtrack</a>(&self) -> <a class="primitive" href="https://doc.rust-lang.org/1.76.0/std/primitive.bool.html">bool</a></h4></section></summary><div class="docblock"><p>Returns whether the bounded backtracking regex engine may be used, as
|
|||
|
|
set by <a href="struct.Config.html#method.backtrack" title="method regex_automata::meta::Config::backtrack"><code>Config::backtrack</code></a>.</p>
|
|||
|
|
<p>If it was not explicitly set, then a default value is returned.</p>
|
|||
|
|
</div></details></div></details></div><h2 id="trait-implementations" class="section-header">Trait Implementations<a href="#trait-implementations" class="anchor">§</a></h2><div id="trait-implementations-list"><details class="toggle implementors-toggle" open><summary><section id="impl-Clone-for-Config" class="impl"><a class="src rightside" href="../../src/regex_automata/meta/regex.rs.html#2427">source</a><a href="#impl-Clone-for-Config" class="anchor">§</a><h3 class="code-header">impl <a class="trait" href="https://doc.rust-lang.org/1.76.0/core/clone/trait.Clone.html" title="trait core::clone::Clone">Clone</a> for <a class="struct" href="struct.Config.html" title="struct regex_automata::meta::Config">Config</a></h3></section></summary><div class="impl-items"><details class="toggle method-toggle" open><summary><section id="method.clone" class="method trait-impl"><a class="src rightside" href="../../src/regex_automata/meta/regex.rs.html#2427">source</a><a href="#method.clone" class="anchor">§</a><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.76.0/core/clone/trait.Clone.html#tymethod.clone" class="fn">clone</a>(&self) -> <a class="struct" href="struct.Config.html" title="struct regex_automata::meta::Config">Config</a></h4></section></summary><div class='docblock'>Returns a copy of the value. <a href="https://doc.rust-lang.org/1.76.0/core/clone/trait.Clone.html#tymethod.clone">Read more</a></div></details><details class="toggle method-toggle" open><summary><section id="method.clone_from" class="method trait-impl"><span class="rightside"><span class="since" title="Stable since Rust version 1.0.0">1.0.0</span> · <a class="src" href="https://doc.rust-lang.org/1.76.0/src/core/clone.rs.html#169">source</a></span><a href="#method.clone_from" class="anchor">§</a><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.76.0/core/clone/trait.Clone.html#method.clone_from" class="fn">clone_from</a>(&mut self, source: <a class="primitive" href="https://doc.rust-lang.org/1.76.0/std/primitive.reference.html">&Self</a>)</h4></section></summary><div class='docblock'>Performs copy-assignment from <code>source</code>. <a href="https://doc.rust-lang.org/1.76.0/core/clone/trait.Clone.html#method.clone_from">Read more</a></div></details></div></details><details class="toggle implementors-toggle" open><summary><section id="impl-Debug-for-Config" class="impl"><a class="src rightside" href="../../src/regex_automata/meta/regex.rs.html#2427">source</a><a href="#impl-Debug-for-Config" class="anchor">§</a><h3 class="code-header">impl <a class="trait" href="https://doc.rust-lang.org/1.76.0/core/fmt/trait.Debug.html" title="trait core::fmt::Debug">Debug</a> for <a class="struct" href="struct.Config.html" title="struct regex_automata::meta::Config">Config</a></h3></section></summary><div class="impl-items"><details class="toggle method-toggle" open><summary><section id="method.fmt" class="method trait-impl"><a class="src rightside" href="../../src/regex_automata/meta/regex.rs.html#2427">source</a><a href="#method.fmt" class="anchor">§</a><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.76.0/core/fmt/trait.Debug.html#tymethod.fmt" class="fn">fmt</a>(&self, f: &mut <a class="struct" href="https://doc.rust-lang.org/1.76.0/core/fmt/struct.Formatter.html" title="struct core::fmt::Formatter">Formatter</a><'_>) -> <a class="type" href="https://doc.rust-lang.org/1.76.0/core/fmt/type.Result.html" title="type core::fmt::Result">Result</a></h4></section></summary><div class='docblock'>Formats the value using the given formatter. <a href="https://doc.rust-lang.org/1.76.0/core/fmt/trait.Debug.html#tymethod.fmt">Read more</a></div></details></div></details><details class="toggle implementors-toggle" open><summary><section id="impl-Default-for-Config" class="impl"><a class="src rightside" href="../../src/regex_automata/meta/regex.rs.html#2427">source</a><a href="#impl-Default-for-Config" class="anchor">§</a><h3 class="code-header">impl <a class="trait" href="https://doc.rust-lang.org/1.76.0/co
|
|||
|
|
T: 'static + ?<a class="trait" href="https://doc.rust-lang.org/1.76.0/core/marker/trait.Sized.html" title="trait core::marker::Sized">Sized</a>,</div></h3></section></summary><div class="impl-items"><details class="toggle method-toggle" open><summary><section id="method.type_id" class="method trait-impl"><a class="src rightside" href="https://doc.rust-lang.org/1.76.0/src/core/any.rs.html#141">source</a><a href="#method.type_id" class="anchor">§</a><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.76.0/core/any/trait.Any.html#tymethod.type_id" class="fn">type_id</a>(&self) -> <a class="struct" href="https://doc.rust-lang.org/1.76.0/core/any/struct.TypeId.html" title="struct core::any::TypeId">TypeId</a></h4></section></summary><div class='docblock'>Gets the <code>TypeId</code> of <code>self</code>. <a href="https://doc.rust-lang.org/1.76.0/core/any/trait.Any.html#tymethod.type_id">Read more</a></div></details></div></details><details class="toggle implementors-toggle"><summary><section id="impl-Borrow%3CT%3E-for-T" class="impl"><a class="src rightside" href="https://doc.rust-lang.org/1.76.0/src/core/borrow.rs.html#208">source</a><a href="#impl-Borrow%3CT%3E-for-T" class="anchor">§</a><h3 class="code-header">impl<T> <a class="trait" href="https://doc.rust-lang.org/1.76.0/core/borrow/trait.Borrow.html" title="trait core::borrow::Borrow">Borrow</a><T> for T<div class="where">where
|
|||
|
|
T: ?<a class="trait" href="https://doc.rust-lang.org/1.76.0/core/marker/trait.Sized.html" title="trait core::marker::Sized">Sized</a>,</div></h3></section></summary><div class="impl-items"><details class="toggle method-toggle" open><summary><section id="method.borrow" class="method trait-impl"><a class="src rightside" href="https://doc.rust-lang.org/1.76.0/src/core/borrow.rs.html#210">source</a><a href="#method.borrow" class="anchor">§</a><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.76.0/core/borrow/trait.Borrow.html#tymethod.borrow" class="fn">borrow</a>(&self) -> <a class="primitive" href="https://doc.rust-lang.org/1.76.0/std/primitive.reference.html">&T</a></h4></section></summary><div class='docblock'>Immutably borrows from an owned value. <a href="https://doc.rust-lang.org/1.76.0/core/borrow/trait.Borrow.html#tymethod.borrow">Read more</a></div></details></div></details><details class="toggle implementors-toggle"><summary><section id="impl-BorrowMut%3CT%3E-for-T" class="impl"><a class="src rightside" href="https://doc.rust-lang.org/1.76.0/src/core/borrow.rs.html#216">source</a><a href="#impl-BorrowMut%3CT%3E-for-T" class="anchor">§</a><h3 class="code-header">impl<T> <a class="trait" href="https://doc.rust-lang.org/1.76.0/core/borrow/trait.BorrowMut.html" title="trait core::borrow::BorrowMut">BorrowMut</a><T> for T<div class="where">where
|
|||
|
|
T: ?<a class="trait" href="https://doc.rust-lang.org/1.76.0/core/marker/trait.Sized.html" title="trait core::marker::Sized">Sized</a>,</div></h3></section></summary><div class="impl-items"><details class="toggle method-toggle" open><summary><section id="method.borrow_mut" class="method trait-impl"><a class="src rightside" href="https://doc.rust-lang.org/1.76.0/src/core/borrow.rs.html#217">source</a><a href="#method.borrow_mut" class="anchor">§</a><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.76.0/core/borrow/trait.BorrowMut.html#tymethod.borrow_mut" class="fn">borrow_mut</a>(&mut self) -> <a class="primitive" href="https://doc.rust-lang.org/1.76.0/std/primitive.reference.html">&mut T</a></h4></section></summary><div class='docblock'>Mutably borrows from an owned value. <a href="https://doc.rust-lang.org/1.76.0/core/borrow/trait.BorrowMut.html#tymethod.borrow_mut">Read more</a></div></details></div></details><details class="toggle implementors-toggle"><summary><section id="impl-From%3CT%3E-for-T" class="impl"><a class="src rightside" href="https://doc.rust-lang.org/1.76.0/src/core/convert/mod.rs.html#763">source</a><a href="#impl-From%3CT%3E-for-T" class="anchor">§</a><h3 class="code-header">impl<T> <a class="trait" href="https://doc.rust-lang.org/1.76.0/core/convert/trait.From.html" title="trait core::convert::From">From</a><T> for T</h3></section></summary><div class="impl-items"><details class="toggle method-toggle" open><summary><section id="method.from" class="method trait-impl"><a class="src rightside" href="https://doc.rust-lang.org/1.76.0/src/core/convert/mod.rs.html#766">source</a><a href="#method.from" class="anchor">§</a><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.76.0/core/convert/trait.From.html#tymethod.from" class="fn">from</a>(t: T) -> T</h4></section></summary><div class="docblock"><p>Returns the argument unchanged.</p>
|
|||
|
|
</div></details></div></details><details class="toggle implementors-toggle"><summary><section id="impl-Into%3CU%3E-for-T" class="impl"><a class="src rightside" href="https://doc.rust-lang.org/1.76.0/src/core/convert/mod.rs.html#747-749">source</a><a href="#impl-Into%3CU%3E-for-T" class="anchor">§</a><h3 class="code-header">impl<T, U> <a class="trait" href="https://doc.rust-lang.org/1.76.0/core/convert/trait.Into.html" title="trait core::convert::Into">Into</a><U> for T<div class="where">where
|
|||
|
|
U: <a class="trait" href="https://doc.rust-lang.org/1.76.0/core/convert/trait.From.html" title="trait core::convert::From">From</a><T>,</div></h3></section></summary><div class="impl-items"><details class="toggle method-toggle" open><summary><section id="method.into" class="method trait-impl"><a class="src rightside" href="https://doc.rust-lang.org/1.76.0/src/core/convert/mod.rs.html#756">source</a><a href="#method.into" class="anchor">§</a><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.76.0/core/convert/trait.Into.html#tymethod.into" class="fn">into</a>(self) -> U</h4></section></summary><div class="docblock"><p>Calls <code>U::from(self)</code>.</p>
|
|||
|
|
<p>That is, this conversion is whatever the implementation of
|
|||
|
|
<code><a href="https://doc.rust-lang.org/1.76.0/core/convert/trait.From.html" title="trait core::convert::From">From</a><T> for U</code> chooses to do.</p>
|
|||
|
|
</div></details></div></details><details class="toggle implementors-toggle"><summary><section id="impl-ToOwned-for-T" class="impl"><a class="src rightside" href="https://doc.rust-lang.org/1.76.0/src/alloc/borrow.rs.html#83-85">source</a><a href="#impl-ToOwned-for-T" class="anchor">§</a><h3 class="code-header">impl<T> <a class="trait" href="https://doc.rust-lang.org/1.76.0/alloc/borrow/trait.ToOwned.html" title="trait alloc::borrow::ToOwned">ToOwned</a> for T<div class="where">where
|
|||
|
|
T: <a class="trait" href="https://doc.rust-lang.org/1.76.0/core/clone/trait.Clone.html" title="trait core::clone::Clone">Clone</a>,</div></h3></section></summary><div class="impl-items"><details class="toggle" open><summary><section id="associatedtype.Owned" class="associatedtype trait-impl"><a href="#associatedtype.Owned" class="anchor">§</a><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.76.0/alloc/borrow/trait.ToOwned.html#associatedtype.Owned" class="associatedtype">Owned</a> = T</h4></section></summary><div class='docblock'>The resulting type after obtaining ownership.</div></details><details class="toggle method-toggle" open><summary><section id="method.to_owned" class="method trait-impl"><a class="src rightside" href="https://doc.rust-lang.org/1.76.0/src/alloc/borrow.rs.html#88">source</a><a href="#method.to_owned" class="anchor">§</a><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.76.0/alloc/borrow/trait.ToOwned.html#tymethod.to_owned" class="fn">to_owned</a>(&self) -> T</h4></section></summary><div class='docblock'>Creates owned data from borrowed data, usually by cloning. <a href="https://doc.rust-lang.org/1.76.0/alloc/borrow/trait.ToOwned.html#tymethod.to_owned">Read more</a></div></details><details class="toggle method-toggle" open><summary><section id="method.clone_into" class="method trait-impl"><a class="src rightside" href="https://doc.rust-lang.org/1.76.0/src/alloc/borrow.rs.html#92">source</a><a href="#method.clone_into" class="anchor">§</a><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.76.0/alloc/borrow/trait.ToOwned.html#method.clone_into" class="fn">clone_into</a>(&self, target: <a class="primitive" href="https://doc.rust-lang.org/1.76.0/std/primitive.reference.html">&mut T</a>)</h4></section></summary><div class='docblock'>Uses borrowed data to replace owned data, usually by cloning. <a href="https://doc.rust-lang.org/1.76.0/alloc/borrow/trait.ToOwned.html#method.clone_into">Read more</a></div></details></div></details><details class="toggle implementors-toggle"><summary><section id="impl-TryFrom%3CU%3E-for-T" class="impl"><a class="src rightside" href="https://doc.rust-lang.org/1.76.0/src/core/convert/mod.rs.html#803-805">source</a><a href="#impl-TryFrom%3CU%3E-for-T" class="anchor">§</a><h3 class="code-header">impl<T, U> <a class="trait" href="https://doc.rust-lang.org/1.76.0/core/convert/trait.TryFrom.html" title="trait core::convert::TryFrom">TryFrom</a><U> for T<div class="where">where
|
|||
|
|
U: <a class="trait" href="https://doc.rust-lang.org/1.76.0/core/convert/trait.Into.html" title="trait core::convert::Into">Into</a><T>,</div></h3></section></summary><div class="impl-items"><details class="toggle" open><summary><section id="associatedtype.Error" class="associatedtype trait-impl"><a href="#associatedtype.Error" class="anchor">§</a><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.76.0/core/convert/trait.TryFrom.html#associatedtype.Error" class="associatedtype">Error</a> = <a class="enum" href="https://doc.rust-lang.org/1.76.0/core/convert/enum.Infallible.html" title="enum core::convert::Infallible">Infallible</a></h4></section></summary><div class='docblock'>The type returned in the event of a conversion error.</div></details><details class="toggle method-toggle" open><summary><section id="method.try_from" class="method trait-impl"><a class="src rightside" href="https://doc.rust-lang.org/1.76.0/src/core/convert/mod.rs.html#810">source</a><a href="#method.try_from" class="anchor">§</a><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.76.0/core/convert/trait.TryFrom.html#tymethod.try_from" class="fn">try_from</a>(value: U) -> <a class="enum" href="https://doc.rust-lang.org/1.76.0/core/result/enum.Result.html" title="enum core::result::Result">Result</a><T, <T as <a class="trait" href="https://doc.rust-lang.org/1.76.0/core/convert/trait.TryFrom.html" title="trait core::convert::TryFrom">TryFrom</a><U>>::<a class="associatedtype" href="https://doc.rust-lang.org/1.76.0/core/convert/trait.TryFrom.html#associatedtype.Error" title="type core::convert::TryFrom::Error">Error</a>></h4></section></summary><div class='docblock'>Performs the conversion.</div></details></div></details><details class="toggle implementors-toggle"><summary><section id="impl-TryInto%3CU%3E-for-T" class="impl"><a class="src rightside" href="https://doc.rust-lang.org/1.76.0/src/core/convert/mod.rs.html#788-790">source</a><a href="#impl-TryInto%3CU%3E-for-T" class="anchor">§</a><h3 class="code-header">impl<T, U> <a class="trait" href="https://doc.rust-lang.org/1.76.0/core/convert/trait.TryInto.html" title="trait core::convert::TryInto">TryInto</a><U> for T<div class="where">where
|
|||
|
|
U: <a class="trait" href="https://doc.rust-lang.org/1.76.0/core/convert/trait.TryFrom.html" title="trait core::convert::TryFrom">TryFrom</a><T>,</div></h3></section></summary><div class="impl-items"><details class="toggle" open><summary><section id="associatedtype.Error-1" class="associatedtype trait-impl"><a href="#associatedtype.Error-1" class="anchor">§</a><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.76.0/core/convert/trait.TryInto.html#associatedtype.Error" class="associatedtype">Error</a> = <U as <a class="trait" href="https://doc.rust-lang.org/1.76.0/core/convert/trait.TryFrom.html" title="trait core::convert::TryFrom">TryFrom</a><T>>::<a class="associatedtype" href="https://doc.rust-lang.org/1.76.0/core/convert/trait.TryFrom.html#associatedtype.Error" title="type core::convert::TryFrom::Error">Error</a></h4></section></summary><div class='docblock'>The type returned in the event of a conversion error.</div></details><details class="toggle method-toggle" open><summary><section id="method.try_into" class="method trait-impl"><a class="src rightside" href="https://doc.rust-lang.org/1.76.0/src/core/convert/mod.rs.html#795">source</a><a href="#method.try_into" class="anchor">§</a><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.76.0/core/convert/trait.TryInto.html#tymethod.try_into" class="fn">try_into</a>(self) -> <a class="enum" href="https://doc.rust-lang.org/1.76.0/core/result/enum.Result.html" title="enum core::result::Result">Result</a><U, <U as <a class="trait" href="https://doc.rust-lang.org/1.76.0/core/convert/trait.TryFrom.html" title="trait core::convert::TryFrom">TryFrom</a><T>>::<a class="associatedtype" href="https://doc.rust-lang.org/1.76.0/core/convert/trait.TryFrom.html#associatedtype.Error" title="type core::convert::TryFrom::Error">Error</a>></h4></section></summary><div class='docblock'>Performs the conversion.</div></details></div></details></div></section></div></main></body></html>
|