Files
rapr-rs/docs/src/form_urlencoded/lib.rs.html
T
Uttarayan Mondal d5ecda4c73 Initial docs commit
2021-03-15 01:27:34 +05:30

847 lines
60 KiB
HTML
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
<!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="Source of the Rust file `/home/fs0c131y/.local/share/cargo/registry/src/github.com-1ecc6299db9ec823/form_urlencoded-1.0.1/src/lib.rs`."><meta name="keywords" content="rust, rustlang, rust-lang"><title>lib.rs - source</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="../../light.css" id="themeStyle"><link rel="stylesheet" type="text/css" href="../../dark.css" disabled ><link rel="stylesheet" type="text/css" href="../../ayu.css" disabled ><script id="default-settings"></script><script src="../../storage.js"></script><noscript><link rel="stylesheet" href="../../noscript.css"></noscript><link rel="icon" type="image/svg+xml" href="../../favicon.svg">
<link rel="alternate icon" type="image/png" href="../../favicon-16x16.png">
<link rel="alternate icon" type="image/png" href="../../favicon-32x32.png"><style type="text/css">#crate-search{background-image:url("../../down-arrow.svg");}</style></head><body class="rustdoc source"><!--[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">&#9776;</div><a href='../../form_urlencoded/index.html'><div class='logo-container rust-logo'><img src='../../rust-logo.png' alt='logo'></div></a></nav><div class="theme-picker"><button id="theme-picker" aria-label="Pick another theme!" aria-haspopup="menu"><img src="../../brush.svg" width="18" alt="Pick another theme!"></button><div id="theme-choices" role="menu"></div></div><script src="../../theme.js"></script><nav class="sub"><form class="search-form"><div class="search-container"><div><select id="crate-search"><option value="All crates">All crates</option></select><input class="search-input" name="search" disabled autocomplete="off" spellcheck="false" placeholder="Click or press S to search, ? for more options…" type="search"></div><button type="button" class="help-button">?</button>
<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"><pre class="line-numbers"><span id="1"> 1</span>
<span id="2"> 2</span>
<span id="3"> 3</span>
<span id="4"> 4</span>
<span id="5"> 5</span>
<span id="6"> 6</span>
<span id="7"> 7</span>
<span id="8"> 8</span>
<span id="9"> 9</span>
<span id="10"> 10</span>
<span id="11"> 11</span>
<span id="12"> 12</span>
<span id="13"> 13</span>
<span id="14"> 14</span>
<span id="15"> 15</span>
<span id="16"> 16</span>
<span id="17"> 17</span>
<span id="18"> 18</span>
<span id="19"> 19</span>
<span id="20"> 20</span>
<span id="21"> 21</span>
<span id="22"> 22</span>
<span id="23"> 23</span>
<span id="24"> 24</span>
<span id="25"> 25</span>
<span id="26"> 26</span>
<span id="27"> 27</span>
<span id="28"> 28</span>
<span id="29"> 29</span>
<span id="30"> 30</span>
<span id="31"> 31</span>
<span id="32"> 32</span>
<span id="33"> 33</span>
<span id="34"> 34</span>
<span id="35"> 35</span>
<span id="36"> 36</span>
<span id="37"> 37</span>
<span id="38"> 38</span>
<span id="39"> 39</span>
<span id="40"> 40</span>
<span id="41"> 41</span>
<span id="42"> 42</span>
<span id="43"> 43</span>
<span id="44"> 44</span>
<span id="45"> 45</span>
<span id="46"> 46</span>
<span id="47"> 47</span>
<span id="48"> 48</span>
<span id="49"> 49</span>
<span id="50"> 50</span>
<span id="51"> 51</span>
<span id="52"> 52</span>
<span id="53"> 53</span>
<span id="54"> 54</span>
<span id="55"> 55</span>
<span id="56"> 56</span>
<span id="57"> 57</span>
<span id="58"> 58</span>
<span id="59"> 59</span>
<span id="60"> 60</span>
<span id="61"> 61</span>
<span id="62"> 62</span>
<span id="63"> 63</span>
<span id="64"> 64</span>
<span id="65"> 65</span>
<span id="66"> 66</span>
<span id="67"> 67</span>
<span id="68"> 68</span>
<span id="69"> 69</span>
<span id="70"> 70</span>
<span id="71"> 71</span>
<span id="72"> 72</span>
<span id="73"> 73</span>
<span id="74"> 74</span>
<span id="75"> 75</span>
<span id="76"> 76</span>
<span id="77"> 77</span>
<span id="78"> 78</span>
<span id="79"> 79</span>
<span id="80"> 80</span>
<span id="81"> 81</span>
<span id="82"> 82</span>
<span id="83"> 83</span>
<span id="84"> 84</span>
<span id="85"> 85</span>
<span id="86"> 86</span>
<span id="87"> 87</span>
<span id="88"> 88</span>
<span id="89"> 89</span>
<span id="90"> 90</span>
<span id="91"> 91</span>
<span id="92"> 92</span>
<span id="93"> 93</span>
<span id="94"> 94</span>
<span id="95"> 95</span>
<span id="96"> 96</span>
<span id="97"> 97</span>
<span id="98"> 98</span>
<span id="99"> 99</span>
<span id="100">100</span>
<span id="101">101</span>
<span id="102">102</span>
<span id="103">103</span>
<span id="104">104</span>
<span id="105">105</span>
<span id="106">106</span>
<span id="107">107</span>
<span id="108">108</span>
<span id="109">109</span>
<span id="110">110</span>
<span id="111">111</span>
<span id="112">112</span>
<span id="113">113</span>
<span id="114">114</span>
<span id="115">115</span>
<span id="116">116</span>
<span id="117">117</span>
<span id="118">118</span>
<span id="119">119</span>
<span id="120">120</span>
<span id="121">121</span>
<span id="122">122</span>
<span id="123">123</span>
<span id="124">124</span>
<span id="125">125</span>
<span id="126">126</span>
<span id="127">127</span>
<span id="128">128</span>
<span id="129">129</span>
<span id="130">130</span>
<span id="131">131</span>
<span id="132">132</span>
<span id="133">133</span>
<span id="134">134</span>
<span id="135">135</span>
<span id="136">136</span>
<span id="137">137</span>
<span id="138">138</span>
<span id="139">139</span>
<span id="140">140</span>
<span id="141">141</span>
<span id="142">142</span>
<span id="143">143</span>
<span id="144">144</span>
<span id="145">145</span>
<span id="146">146</span>
<span id="147">147</span>
<span id="148">148</span>
<span id="149">149</span>
<span id="150">150</span>
<span id="151">151</span>
<span id="152">152</span>
<span id="153">153</span>
<span id="154">154</span>
<span id="155">155</span>
<span id="156">156</span>
<span id="157">157</span>
<span id="158">158</span>
<span id="159">159</span>
<span id="160">160</span>
<span id="161">161</span>
<span id="162">162</span>
<span id="163">163</span>
<span id="164">164</span>
<span id="165">165</span>
<span id="166">166</span>
<span id="167">167</span>
<span id="168">168</span>
<span id="169">169</span>
<span id="170">170</span>
<span id="171">171</span>
<span id="172">172</span>
<span id="173">173</span>
<span id="174">174</span>
<span id="175">175</span>
<span id="176">176</span>
<span id="177">177</span>
<span id="178">178</span>
<span id="179">179</span>
<span id="180">180</span>
<span id="181">181</span>
<span id="182">182</span>
<span id="183">183</span>
<span id="184">184</span>
<span id="185">185</span>
<span id="186">186</span>
<span id="187">187</span>
<span id="188">188</span>
<span id="189">189</span>
<span id="190">190</span>
<span id="191">191</span>
<span id="192">192</span>
<span id="193">193</span>
<span id="194">194</span>
<span id="195">195</span>
<span id="196">196</span>
<span id="197">197</span>
<span id="198">198</span>
<span id="199">199</span>
<span id="200">200</span>
<span id="201">201</span>
<span id="202">202</span>
<span id="203">203</span>
<span id="204">204</span>
<span id="205">205</span>
<span id="206">206</span>
<span id="207">207</span>
<span id="208">208</span>
<span id="209">209</span>
<span id="210">210</span>
<span id="211">211</span>
<span id="212">212</span>
<span id="213">213</span>
<span id="214">214</span>
<span id="215">215</span>
<span id="216">216</span>
<span id="217">217</span>
<span id="218">218</span>
<span id="219">219</span>
<span id="220">220</span>
<span id="221">221</span>
<span id="222">222</span>
<span id="223">223</span>
<span id="224">224</span>
<span id="225">225</span>
<span id="226">226</span>
<span id="227">227</span>
<span id="228">228</span>
<span id="229">229</span>
<span id="230">230</span>
<span id="231">231</span>
<span id="232">232</span>
<span id="233">233</span>
<span id="234">234</span>
<span id="235">235</span>
<span id="236">236</span>
<span id="237">237</span>
<span id="238">238</span>
<span id="239">239</span>
<span id="240">240</span>
<span id="241">241</span>
<span id="242">242</span>
<span id="243">243</span>
<span id="244">244</span>
<span id="245">245</span>
<span id="246">246</span>
<span id="247">247</span>
<span id="248">248</span>
<span id="249">249</span>
<span id="250">250</span>
<span id="251">251</span>
<span id="252">252</span>
<span id="253">253</span>
<span id="254">254</span>
<span id="255">255</span>
<span id="256">256</span>
<span id="257">257</span>
<span id="258">258</span>
<span id="259">259</span>
<span id="260">260</span>
<span id="261">261</span>
<span id="262">262</span>
<span id="263">263</span>
<span id="264">264</span>
<span id="265">265</span>
<span id="266">266</span>
<span id="267">267</span>
<span id="268">268</span>
<span id="269">269</span>
<span id="270">270</span>
<span id="271">271</span>
<span id="272">272</span>
<span id="273">273</span>
<span id="274">274</span>
<span id="275">275</span>
<span id="276">276</span>
<span id="277">277</span>
<span id="278">278</span>
<span id="279">279</span>
<span id="280">280</span>
<span id="281">281</span>
<span id="282">282</span>
<span id="283">283</span>
<span id="284">284</span>
<span id="285">285</span>
<span id="286">286</span>
<span id="287">287</span>
<span id="288">288</span>
<span id="289">289</span>
<span id="290">290</span>
<span id="291">291</span>
<span id="292">292</span>
<span id="293">293</span>
<span id="294">294</span>
<span id="295">295</span>
<span id="296">296</span>
<span id="297">297</span>
<span id="298">298</span>
<span id="299">299</span>
<span id="300">300</span>
<span id="301">301</span>
<span id="302">302</span>
<span id="303">303</span>
<span id="304">304</span>
<span id="305">305</span>
<span id="306">306</span>
<span id="307">307</span>
<span id="308">308</span>
<span id="309">309</span>
<span id="310">310</span>
<span id="311">311</span>
<span id="312">312</span>
<span id="313">313</span>
<span id="314">314</span>
<span id="315">315</span>
<span id="316">316</span>
<span id="317">317</span>
<span id="318">318</span>
<span id="319">319</span>
<span id="320">320</span>
<span id="321">321</span>
<span id="322">322</span>
<span id="323">323</span>
<span id="324">324</span>
<span id="325">325</span>
<span id="326">326</span>
<span id="327">327</span>
<span id="328">328</span>
<span id="329">329</span>
<span id="330">330</span>
<span id="331">331</span>
<span id="332">332</span>
<span id="333">333</span>
<span id="334">334</span>
<span id="335">335</span>
<span id="336">336</span>
<span id="337">337</span>
<span id="338">338</span>
<span id="339">339</span>
<span id="340">340</span>
<span id="341">341</span>
<span id="342">342</span>
<span id="343">343</span>
<span id="344">344</span>
<span id="345">345</span>
<span id="346">346</span>
<span id="347">347</span>
<span id="348">348</span>
<span id="349">349</span>
<span id="350">350</span>
<span id="351">351</span>
<span id="352">352</span>
<span id="353">353</span>
<span id="354">354</span>
<span id="355">355</span>
<span id="356">356</span>
<span id="357">357</span>
<span id="358">358</span>
<span id="359">359</span>
<span id="360">360</span>
<span id="361">361</span>
<span id="362">362</span>
<span id="363">363</span>
<span id="364">364</span>
<span id="365">365</span>
<span id="366">366</span>
<span id="367">367</span>
<span id="368">368</span>
<span id="369">369</span>
<span id="370">370</span>
<span id="371">371</span>
<span id="372">372</span>
<span id="373">373</span>
<span id="374">374</span>
<span id="375">375</span>
<span id="376">376</span>
<span id="377">377</span>
<span id="378">378</span>
<span id="379">379</span>
<span id="380">380</span>
<span id="381">381</span>
<span id="382">382</span>
<span id="383">383</span>
<span id="384">384</span>
<span id="385">385</span>
<span id="386">386</span>
<span id="387">387</span>
<span id="388">388</span>
<span id="389">389</span>
<span id="390">390</span>
<span id="391">391</span>
<span id="392">392</span>
<span id="393">393</span>
<span id="394">394</span>
<span id="395">395</span>
<span id="396">396</span>
<span id="397">397</span>
<span id="398">398</span>
<span id="399">399</span>
<span id="400">400</span>
<span id="401">401</span>
<span id="402">402</span>
<span id="403">403</span>
<span id="404">404</span>
<span id="405">405</span>
<span id="406">406</span>
<span id="407">407</span>
<span id="408">408</span>
<span id="409">409</span>
<span id="410">410</span>
<span id="411">411</span>
<span id="412">412</span>
<span id="413">413</span>
<span id="414">414</span>
<span id="415">415</span>
<span id="416">416</span>
<span id="417">417</span>
<span id="418">418</span>
<span id="419">419</span>
<span id="420">420</span>
</pre><div class="example-wrap"><pre class="rust ">
<span class="comment">// Copyright 2013-2016 The rust-url developers.</span>
<span class="comment">//</span>
<span class="comment">// Licensed under the Apache License, Version 2.0 &lt;LICENSE-APACHE or</span>
<span class="comment">// http://www.apache.org/licenses/LICENSE-2.0&gt; or the MIT license</span>
<span class="comment">// &lt;LICENSE-MIT or http://opensource.org/licenses/MIT&gt;, at your</span>
<span class="comment">// option. This file may not be copied, modified, or distributed</span>
<span class="comment">// except according to those terms.</span>
<span class="doccomment">//! Parser and serializer for the [`application/x-www-form-urlencoded` syntax](</span>
<span class="doccomment">//! http://url.spec.whatwg.org/#application/x-www-form-urlencoded),</span>
<span class="doccomment">//! as used by HTML forms.</span>
<span class="doccomment">//!</span>
<span class="doccomment">//! Converts between a string (such as an URLs query string)</span>
<span class="doccomment">//! and a sequence of (name, value) pairs.</span>
<span class="attribute">#[<span class="ident">macro_use</span>]</span>
<span class="kw">extern</span> <span class="kw">crate</span> <span class="ident">matches</span>;
<span class="kw">use</span> <span class="ident">percent_encoding</span>::{<span class="ident">percent_decode</span>, <span class="ident">percent_encode_byte</span>};
<span class="kw">use</span> <span class="ident">std</span>::<span class="ident">borrow</span>::{<span class="ident">Borrow</span>, <span class="ident">Cow</span>};
<span class="kw">use</span> <span class="ident">std</span>::<span class="ident">str</span>;
<span class="doccomment">/// Convert a byte string in the `application/x-www-form-urlencoded` syntax</span>
<span class="doccomment">/// into a iterator of (name, value) pairs.</span>
<span class="doccomment">///</span>
<span class="doccomment">/// Use `parse(input.as_bytes())` to parse a `&amp;str` string.</span>
<span class="doccomment">///</span>
<span class="doccomment">/// The names and values are percent-decoded. For instance, `%23first=%25try%25` will be</span>
<span class="doccomment">/// converted to `[(&quot;#first&quot;, &quot;%try%&quot;)]`.</span>
<span class="attribute">#[<span class="ident">inline</span>]</span>
<span class="kw">pub</span> <span class="kw">fn</span> <span class="ident">parse</span>(<span class="ident">input</span>: <span class="kw-2">&amp;</span>[<span class="ident">u8</span>]) <span class="op">-</span><span class="op">&gt;</span> <span class="ident">Parse</span><span class="op">&lt;</span><span class="lifetime">&#39;_</span><span class="op">&gt;</span> {
<span class="ident">Parse</span> { <span class="ident">input</span> }
}
<span class="doccomment">/// The return type of `parse()`.</span>
<span class="attribute">#[<span class="ident">derive</span>(<span class="ident">Copy</span>, <span class="ident">Clone</span>)]</span>
<span class="kw">pub</span> <span class="kw">struct</span> <span class="ident">Parse</span><span class="op">&lt;</span><span class="lifetime">&#39;a</span><span class="op">&gt;</span> {
<span class="ident">input</span>: <span class="kw-2">&amp;</span><span class="lifetime">&#39;a</span> [<span class="ident">u8</span>],
}
<span class="kw">impl</span><span class="op">&lt;</span><span class="lifetime">&#39;a</span><span class="op">&gt;</span> <span class="ident">Iterator</span> <span class="kw">for</span> <span class="ident">Parse</span><span class="op">&lt;</span><span class="lifetime">&#39;a</span><span class="op">&gt;</span> {
<span class="kw">type</span> <span class="ident">Item</span> <span class="op">=</span> (<span class="ident">Cow</span><span class="op">&lt;</span><span class="lifetime">&#39;a</span>, <span class="ident">str</span><span class="op">&gt;</span>, <span class="ident">Cow</span><span class="op">&lt;</span><span class="lifetime">&#39;a</span>, <span class="ident">str</span><span class="op">&gt;</span>);
<span class="kw">fn</span> <span class="ident">next</span>(<span class="kw-2">&amp;</span><span class="kw-2">mut</span> <span class="self">self</span>) <span class="op">-</span><span class="op">&gt;</span> <span class="prelude-ty">Option</span><span class="op">&lt;</span><span class="self">Self</span>::<span class="ident">Item</span><span class="op">&gt;</span> {
<span class="kw">loop</span> {
<span class="kw">if</span> <span class="self">self</span>.<span class="ident">input</span>.<span class="ident">is_empty</span>() {
<span class="kw">return</span> <span class="prelude-val">None</span>;
}
<span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">split2</span> <span class="op">=</span> <span class="self">self</span>.<span class="ident">input</span>.<span class="ident">splitn</span>(<span class="number">2</span>, <span class="op">|</span><span class="kw-2">&amp;</span><span class="ident">b</span><span class="op">|</span> <span class="ident">b</span> <span class="op">=</span><span class="op">=</span> <span class="string">b&#39;&amp;&#39;</span>);
<span class="kw">let</span> <span class="ident">sequence</span> <span class="op">=</span> <span class="ident">split2</span>.<span class="ident">next</span>().<span class="ident">unwrap</span>();
<span class="self">self</span>.<span class="ident">input</span> <span class="op">=</span> <span class="ident">split2</span>.<span class="ident">next</span>().<span class="ident">unwrap_or</span>(<span class="kw-2">&amp;</span>[][..]);
<span class="kw">if</span> <span class="ident">sequence</span>.<span class="ident">is_empty</span>() {
<span class="kw">continue</span>;
}
<span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">split2</span> <span class="op">=</span> <span class="ident">sequence</span>.<span class="ident">splitn</span>(<span class="number">2</span>, <span class="op">|</span><span class="kw-2">&amp;</span><span class="ident">b</span><span class="op">|</span> <span class="ident">b</span> <span class="op">=</span><span class="op">=</span> <span class="string">b&#39;=&#39;</span>);
<span class="kw">let</span> <span class="ident">name</span> <span class="op">=</span> <span class="ident">split2</span>.<span class="ident">next</span>().<span class="ident">unwrap</span>();
<span class="kw">let</span> <span class="ident">value</span> <span class="op">=</span> <span class="ident">split2</span>.<span class="ident">next</span>().<span class="ident">unwrap_or</span>(<span class="kw-2">&amp;</span>[][..]);
<span class="kw">return</span> <span class="prelude-val">Some</span>((<span class="ident">decode</span>(<span class="ident">name</span>), <span class="ident">decode</span>(<span class="ident">value</span>)));
}
}
}
<span class="kw">fn</span> <span class="ident">decode</span>(<span class="ident">input</span>: <span class="kw-2">&amp;</span>[<span class="ident">u8</span>]) <span class="op">-</span><span class="op">&gt;</span> <span class="ident">Cow</span><span class="op">&lt;</span><span class="lifetime">&#39;_</span>, <span class="ident">str</span><span class="op">&gt;</span> {
<span class="kw">let</span> <span class="ident">replaced</span> <span class="op">=</span> <span class="ident">replace_plus</span>(<span class="ident">input</span>);
<span class="ident">decode_utf8_lossy</span>(<span class="kw">match</span> <span class="ident">percent_decode</span>(<span class="kw-2">&amp;</span><span class="ident">replaced</span>).<span class="ident">into</span>() {
<span class="ident">Cow</span>::<span class="ident">Owned</span>(<span class="ident">vec</span>) <span class="op">=</span><span class="op">&gt;</span> <span class="ident">Cow</span>::<span class="ident">Owned</span>(<span class="ident">vec</span>),
<span class="ident">Cow</span>::<span class="ident">Borrowed</span>(<span class="kw">_</span>) <span class="op">=</span><span class="op">&gt;</span> <span class="ident">replaced</span>,
})
}
<span class="doccomment">/// Replace b&#39;+&#39; with b&#39; &#39;</span>
<span class="kw">fn</span> <span class="ident">replace_plus</span>(<span class="ident">input</span>: <span class="kw-2">&amp;</span>[<span class="ident">u8</span>]) <span class="op">-</span><span class="op">&gt;</span> <span class="ident">Cow</span><span class="op">&lt;</span><span class="lifetime">&#39;_</span>, [<span class="ident">u8</span>]<span class="op">&gt;</span> {
<span class="kw">match</span> <span class="ident">input</span>.<span class="ident">iter</span>().<span class="ident">position</span>(<span class="op">|</span><span class="kw-2">&amp;</span><span class="ident">b</span><span class="op">|</span> <span class="ident">b</span> <span class="op">=</span><span class="op">=</span> <span class="string">b&#39;+&#39;</span>) {
<span class="prelude-val">None</span> <span class="op">=</span><span class="op">&gt;</span> <span class="ident">Cow</span>::<span class="ident">Borrowed</span>(<span class="ident">input</span>),
<span class="prelude-val">Some</span>(<span class="ident">first_position</span>) <span class="op">=</span><span class="op">&gt;</span> {
<span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">replaced</span> <span class="op">=</span> <span class="ident">input</span>.<span class="ident">to_owned</span>();
<span class="ident">replaced</span>[<span class="ident">first_position</span>] <span class="op">=</span> <span class="string">b&#39; &#39;</span>;
<span class="kw">for</span> <span class="ident">byte</span> <span class="kw">in</span> <span class="kw-2">&amp;</span><span class="kw-2">mut</span> <span class="ident">replaced</span>[<span class="ident">first_position</span> <span class="op">+</span> <span class="number">1</span>..] {
<span class="kw">if</span> <span class="kw-2">*</span><span class="ident">byte</span> <span class="op">=</span><span class="op">=</span> <span class="string">b&#39;+&#39;</span> {
<span class="kw-2">*</span><span class="ident">byte</span> <span class="op">=</span> <span class="string">b&#39; &#39;</span>;
}
}
<span class="ident">Cow</span>::<span class="ident">Owned</span>(<span class="ident">replaced</span>)
}
}
}
<span class="kw">impl</span><span class="op">&lt;</span><span class="lifetime">&#39;a</span><span class="op">&gt;</span> <span class="ident">Parse</span><span class="op">&lt;</span><span class="lifetime">&#39;a</span><span class="op">&gt;</span> {
<span class="doccomment">/// Return a new iterator that yields pairs of `String` instead of pairs of `Cow&lt;str&gt;`.</span>
<span class="kw">pub</span> <span class="kw">fn</span> <span class="ident">into_owned</span>(<span class="self">self</span>) <span class="op">-</span><span class="op">&gt;</span> <span class="ident">ParseIntoOwned</span><span class="op">&lt;</span><span class="lifetime">&#39;a</span><span class="op">&gt;</span> {
<span class="ident">ParseIntoOwned</span> { <span class="ident">inner</span>: <span class="self">self</span> }
}
}
<span class="doccomment">/// Like `Parse`, but yields pairs of `String` instead of pairs of `Cow&lt;str&gt;`.</span>
<span class="kw">pub</span> <span class="kw">struct</span> <span class="ident">ParseIntoOwned</span><span class="op">&lt;</span><span class="lifetime">&#39;a</span><span class="op">&gt;</span> {
<span class="ident">inner</span>: <span class="ident">Parse</span><span class="op">&lt;</span><span class="lifetime">&#39;a</span><span class="op">&gt;</span>,
}
<span class="kw">impl</span><span class="op">&lt;</span><span class="lifetime">&#39;a</span><span class="op">&gt;</span> <span class="ident">Iterator</span> <span class="kw">for</span> <span class="ident">ParseIntoOwned</span><span class="op">&lt;</span><span class="lifetime">&#39;a</span><span class="op">&gt;</span> {
<span class="kw">type</span> <span class="ident">Item</span> <span class="op">=</span> (<span class="ident">String</span>, <span class="ident">String</span>);
<span class="kw">fn</span> <span class="ident">next</span>(<span class="kw-2">&amp;</span><span class="kw-2">mut</span> <span class="self">self</span>) <span class="op">-</span><span class="op">&gt;</span> <span class="prelude-ty">Option</span><span class="op">&lt;</span><span class="self">Self</span>::<span class="ident">Item</span><span class="op">&gt;</span> {
<span class="self">self</span>.<span class="ident">inner</span>
.<span class="ident">next</span>()
.<span class="ident">map</span>(<span class="op">|</span>(<span class="ident">k</span>, <span class="ident">v</span>)<span class="op">|</span> (<span class="ident">k</span>.<span class="ident">into_owned</span>(), <span class="ident">v</span>.<span class="ident">into_owned</span>()))
}
}
<span class="doccomment">/// The [`application/x-www-form-urlencoded` byte serializer](</span>
<span class="doccomment">/// https://url.spec.whatwg.org/#concept-urlencoded-byte-serializer).</span>
<span class="doccomment">///</span>
<span class="doccomment">/// Return an iterator of `&amp;str` slices.</span>
<span class="kw">pub</span> <span class="kw">fn</span> <span class="ident">byte_serialize</span>(<span class="ident">input</span>: <span class="kw-2">&amp;</span>[<span class="ident">u8</span>]) <span class="op">-</span><span class="op">&gt;</span> <span class="ident">ByteSerialize</span><span class="op">&lt;</span><span class="lifetime">&#39;_</span><span class="op">&gt;</span> {
<span class="ident">ByteSerialize</span> { <span class="ident">bytes</span>: <span class="ident">input</span> }
}
<span class="doccomment">/// Return value of `byte_serialize()`.</span>
<span class="attribute">#[<span class="ident">derive</span>(<span class="ident">Debug</span>)]</span>
<span class="kw">pub</span> <span class="kw">struct</span> <span class="ident">ByteSerialize</span><span class="op">&lt;</span><span class="lifetime">&#39;a</span><span class="op">&gt;</span> {
<span class="ident">bytes</span>: <span class="kw-2">&amp;</span><span class="lifetime">&#39;a</span> [<span class="ident">u8</span>],
}
<span class="kw">fn</span> <span class="ident">byte_serialized_unchanged</span>(<span class="ident">byte</span>: <span class="ident">u8</span>) <span class="op">-</span><span class="op">&gt;</span> <span class="ident">bool</span> {
<span class="macro">matches</span><span class="macro">!</span>(<span class="ident">byte</span>, <span class="string">b&#39;*&#39;</span> <span class="op">|</span> <span class="string">b&#39;-&#39;</span> <span class="op">|</span> <span class="string">b&#39;.&#39;</span> <span class="op">|</span> <span class="string">b&#39;0&#39;</span> ..<span class="op">=</span> <span class="string">b&#39;9&#39;</span> <span class="op">|</span> <span class="string">b&#39;A&#39;</span> ..<span class="op">=</span> <span class="string">b&#39;Z&#39;</span> <span class="op">|</span> <span class="string">b&#39;_&#39;</span> <span class="op">|</span> <span class="string">b&#39;a&#39;</span> ..<span class="op">=</span> <span class="string">b&#39;z&#39;</span>)
}
<span class="kw">impl</span><span class="op">&lt;</span><span class="lifetime">&#39;a</span><span class="op">&gt;</span> <span class="ident">Iterator</span> <span class="kw">for</span> <span class="ident">ByteSerialize</span><span class="op">&lt;</span><span class="lifetime">&#39;a</span><span class="op">&gt;</span> {
<span class="kw">type</span> <span class="ident">Item</span> <span class="op">=</span> <span class="kw-2">&amp;</span><span class="lifetime">&#39;a</span> <span class="ident">str</span>;
<span class="kw">fn</span> <span class="ident">next</span>(<span class="kw-2">&amp;</span><span class="kw-2">mut</span> <span class="self">self</span>) <span class="op">-</span><span class="op">&gt;</span> <span class="prelude-ty">Option</span><span class="op">&lt;</span><span class="kw-2">&amp;</span><span class="lifetime">&#39;a</span> <span class="ident">str</span><span class="op">&gt;</span> {
<span class="kw">if</span> <span class="kw">let</span> <span class="prelude-val">Some</span>((<span class="kw-2">&amp;</span><span class="ident">first</span>, <span class="ident">tail</span>)) <span class="op">=</span> <span class="self">self</span>.<span class="ident">bytes</span>.<span class="ident">split_first</span>() {
<span class="kw">if</span> <span class="op">!</span><span class="ident">byte_serialized_unchanged</span>(<span class="ident">first</span>) {
<span class="self">self</span>.<span class="ident">bytes</span> <span class="op">=</span> <span class="ident">tail</span>;
<span class="kw">return</span> <span class="prelude-val">Some</span>(<span class="kw">if</span> <span class="ident">first</span> <span class="op">=</span><span class="op">=</span> <span class="string">b&#39; &#39;</span> {
<span class="string">&quot;+&quot;</span>
} <span class="kw">else</span> {
<span class="ident">percent_encode_byte</span>(<span class="ident">first</span>)
});
}
<span class="kw">let</span> <span class="ident">position</span> <span class="op">=</span> <span class="ident">tail</span>.<span class="ident">iter</span>().<span class="ident">position</span>(<span class="op">|</span><span class="kw-2">&amp;</span><span class="ident">b</span><span class="op">|</span> <span class="op">!</span><span class="ident">byte_serialized_unchanged</span>(<span class="ident">b</span>));
<span class="kw">let</span> (<span class="ident">unchanged_slice</span>, <span class="ident">remaining</span>) <span class="op">=</span> <span class="kw">match</span> <span class="ident">position</span> {
<span class="comment">// 1 for first_byte + i unchanged in tail</span>
<span class="prelude-val">Some</span>(<span class="ident">i</span>) <span class="op">=</span><span class="op">&gt;</span> <span class="self">self</span>.<span class="ident">bytes</span>.<span class="ident">split_at</span>(<span class="number">1</span> <span class="op">+</span> <span class="ident">i</span>),
<span class="prelude-val">None</span> <span class="op">=</span><span class="op">&gt;</span> (<span class="self">self</span>.<span class="ident">bytes</span>, <span class="kw-2">&amp;</span>[][..]),
};
<span class="self">self</span>.<span class="ident">bytes</span> <span class="op">=</span> <span class="ident">remaining</span>;
<span class="comment">// This unsafe is appropriate because we have already checked these</span>
<span class="comment">// bytes in byte_serialized_unchanged, which checks for a subset</span>
<span class="comment">// of UTF-8. So we know these bytes are valid UTF-8, and doing</span>
<span class="comment">// another UTF-8 check would be wasteful.</span>
<span class="prelude-val">Some</span>(<span class="kw">unsafe</span> { <span class="ident">str</span>::<span class="ident">from_utf8_unchecked</span>(<span class="ident">unchanged_slice</span>) })
} <span class="kw">else</span> {
<span class="prelude-val">None</span>
}
}
<span class="kw">fn</span> <span class="ident">size_hint</span>(<span class="kw-2">&amp;</span><span class="self">self</span>) <span class="op">-</span><span class="op">&gt;</span> (<span class="ident">usize</span>, <span class="prelude-ty">Option</span><span class="op">&lt;</span><span class="ident">usize</span><span class="op">&gt;</span>) {
<span class="kw">if</span> <span class="self">self</span>.<span class="ident">bytes</span>.<span class="ident">is_empty</span>() {
(<span class="number">0</span>, <span class="prelude-val">Some</span>(<span class="number">0</span>))
} <span class="kw">else</span> {
(<span class="number">1</span>, <span class="prelude-val">Some</span>(<span class="self">self</span>.<span class="ident">bytes</span>.<span class="ident">len</span>()))
}
}
}
<span class="doccomment">/// The [`application/x-www-form-urlencoded` serializer](</span>
<span class="doccomment">/// https://url.spec.whatwg.org/#concept-urlencoded-serializer).</span>
<span class="kw">pub</span> <span class="kw">struct</span> <span class="ident">Serializer</span><span class="op">&lt;</span><span class="lifetime">&#39;a</span>, <span class="ident">T</span>: <span class="ident">Target</span><span class="op">&gt;</span> {
<span class="ident">target</span>: <span class="prelude-ty">Option</span><span class="op">&lt;</span><span class="ident">T</span><span class="op">&gt;</span>,
<span class="ident">start_position</span>: <span class="ident">usize</span>,
<span class="ident">encoding</span>: <span class="ident">EncodingOverride</span><span class="op">&lt;</span><span class="lifetime">&#39;a</span><span class="op">&gt;</span>,
}
<span class="kw">pub</span> <span class="kw">trait</span> <span class="ident">Target</span> {
<span class="kw">fn</span> <span class="ident">as_mut_string</span>(<span class="kw-2">&amp;</span><span class="kw-2">mut</span> <span class="self">self</span>) <span class="op">-</span><span class="op">&gt;</span> <span class="kw-2">&amp;</span><span class="kw-2">mut</span> <span class="ident">String</span>;
<span class="kw">fn</span> <span class="ident">finish</span>(<span class="self">self</span>) <span class="op">-</span><span class="op">&gt;</span> <span class="self">Self</span>::<span class="ident">Finished</span>;
<span class="kw">type</span> <span class="ident">Finished</span>;
}
<span class="kw">impl</span> <span class="ident">Target</span> <span class="kw">for</span> <span class="ident">String</span> {
<span class="kw">fn</span> <span class="ident">as_mut_string</span>(<span class="kw-2">&amp;</span><span class="kw-2">mut</span> <span class="self">self</span>) <span class="op">-</span><span class="op">&gt;</span> <span class="kw-2">&amp;</span><span class="kw-2">mut</span> <span class="ident">String</span> {
<span class="self">self</span>
}
<span class="kw">fn</span> <span class="ident">finish</span>(<span class="self">self</span>) <span class="op">-</span><span class="op">&gt;</span> <span class="self">Self</span> {
<span class="self">self</span>
}
<span class="kw">type</span> <span class="ident">Finished</span> <span class="op">=</span> <span class="self">Self</span>;
}
<span class="kw">impl</span><span class="op">&lt;</span><span class="lifetime">&#39;a</span><span class="op">&gt;</span> <span class="ident">Target</span> <span class="kw">for</span> <span class="kw-2">&amp;</span><span class="lifetime">&#39;a</span> <span class="kw-2">mut</span> <span class="ident">String</span> {
<span class="kw">fn</span> <span class="ident">as_mut_string</span>(<span class="kw-2">&amp;</span><span class="kw-2">mut</span> <span class="self">self</span>) <span class="op">-</span><span class="op">&gt;</span> <span class="kw-2">&amp;</span><span class="kw-2">mut</span> <span class="ident">String</span> {
<span class="kw-2">&amp;</span><span class="kw-2">mut</span> <span class="kw-2">*</span><span class="kw-2">*</span><span class="self">self</span>
}
<span class="kw">fn</span> <span class="ident">finish</span>(<span class="self">self</span>) <span class="op">-</span><span class="op">&gt;</span> <span class="self">Self</span> {
<span class="self">self</span>
}
<span class="kw">type</span> <span class="ident">Finished</span> <span class="op">=</span> <span class="self">Self</span>;
}
<span class="kw">impl</span><span class="op">&lt;</span><span class="lifetime">&#39;a</span>, <span class="ident">T</span>: <span class="ident">Target</span><span class="op">&gt;</span> <span class="ident">Serializer</span><span class="op">&lt;</span><span class="lifetime">&#39;a</span>, <span class="ident">T</span><span class="op">&gt;</span> {
<span class="doccomment">/// Create a new `application/x-www-form-urlencoded` serializer for the given target.</span>
<span class="doccomment">///</span>
<span class="doccomment">/// If the target is non-empty,</span>
<span class="doccomment">/// its content is assumed to already be in `application/x-www-form-urlencoded` syntax.</span>
<span class="kw">pub</span> <span class="kw">fn</span> <span class="ident">new</span>(<span class="ident">target</span>: <span class="ident">T</span>) <span class="op">-</span><span class="op">&gt;</span> <span class="self">Self</span> {
<span class="self">Self</span>::<span class="ident">for_suffix</span>(<span class="ident">target</span>, <span class="number">0</span>)
}
<span class="doccomment">/// Create a new `application/x-www-form-urlencoded` serializer</span>
<span class="doccomment">/// for a suffix of the given target.</span>
<span class="doccomment">///</span>
<span class="doccomment">/// If that suffix is non-empty,</span>
<span class="doccomment">/// its content is assumed to already be in `application/x-www-form-urlencoded` syntax.</span>
<span class="kw">pub</span> <span class="kw">fn</span> <span class="ident">for_suffix</span>(<span class="kw-2">mut</span> <span class="ident">target</span>: <span class="ident">T</span>, <span class="ident">start_position</span>: <span class="ident">usize</span>) <span class="op">-</span><span class="op">&gt;</span> <span class="self">Self</span> {
<span class="kw">if</span> <span class="ident">target</span>.<span class="ident">as_mut_string</span>().<span class="ident">len</span>() <span class="op">&lt;</span> <span class="ident">start_position</span> {
<span class="macro">panic</span><span class="macro">!</span>(
<span class="string">&quot;invalid length {} for target of length {}&quot;</span>,
<span class="ident">start_position</span>,
<span class="ident">target</span>.<span class="ident">as_mut_string</span>().<span class="ident">len</span>()
);
}
<span class="ident">Serializer</span> {
<span class="ident">target</span>: <span class="prelude-val">Some</span>(<span class="ident">target</span>),
<span class="ident">start_position</span>,
<span class="ident">encoding</span>: <span class="prelude-val">None</span>,
}
}
<span class="doccomment">/// Remove any existing name/value pair.</span>
<span class="doccomment">///</span>
<span class="doccomment">/// Panics if called after `.finish()`.</span>
<span class="kw">pub</span> <span class="kw">fn</span> <span class="ident">clear</span>(<span class="kw-2">&amp;</span><span class="kw-2">mut</span> <span class="self">self</span>) <span class="op">-</span><span class="op">&gt;</span> <span class="kw-2">&amp;</span><span class="kw-2">mut</span> <span class="self">Self</span> {
<span class="ident">string</span>(<span class="kw-2">&amp;</span><span class="kw-2">mut</span> <span class="self">self</span>.<span class="ident">target</span>).<span class="ident">truncate</span>(<span class="self">self</span>.<span class="ident">start_position</span>);
<span class="self">self</span>
}
<span class="doccomment">/// Set the character encoding to be used for names and values before percent-encoding.</span>
<span class="kw">pub</span> <span class="kw">fn</span> <span class="ident">encoding_override</span>(<span class="kw-2">&amp;</span><span class="kw-2">mut</span> <span class="self">self</span>, <span class="ident">new</span>: <span class="ident">EncodingOverride</span><span class="op">&lt;</span><span class="lifetime">&#39;a</span><span class="op">&gt;</span>) <span class="op">-</span><span class="op">&gt;</span> <span class="kw-2">&amp;</span><span class="kw-2">mut</span> <span class="self">Self</span> {
<span class="self">self</span>.<span class="ident">encoding</span> <span class="op">=</span> <span class="ident">new</span>;
<span class="self">self</span>
}
<span class="doccomment">/// Serialize and append a name/value pair.</span>
<span class="doccomment">///</span>
<span class="doccomment">/// Panics if called after `.finish()`.</span>
<span class="kw">pub</span> <span class="kw">fn</span> <span class="ident">append_pair</span>(<span class="kw-2">&amp;</span><span class="kw-2">mut</span> <span class="self">self</span>, <span class="ident">name</span>: <span class="kw-2">&amp;</span><span class="ident">str</span>, <span class="ident">value</span>: <span class="kw-2">&amp;</span><span class="ident">str</span>) <span class="op">-</span><span class="op">&gt;</span> <span class="kw-2">&amp;</span><span class="kw-2">mut</span> <span class="self">Self</span> {
<span class="ident">append_pair</span>(
<span class="ident">string</span>(<span class="kw-2">&amp;</span><span class="kw-2">mut</span> <span class="self">self</span>.<span class="ident">target</span>),
<span class="self">self</span>.<span class="ident">start_position</span>,
<span class="self">self</span>.<span class="ident">encoding</span>,
<span class="ident">name</span>,
<span class="ident">value</span>,
);
<span class="self">self</span>
}
<span class="doccomment">/// Serialize and append a name of parameter without any value.</span>
<span class="doccomment">///</span>
<span class="doccomment">/// Panics if called after `.finish()`.</span>
<span class="kw">pub</span> <span class="kw">fn</span> <span class="ident">append_key_only</span>(<span class="kw-2">&amp;</span><span class="kw-2">mut</span> <span class="self">self</span>, <span class="ident">name</span>: <span class="kw-2">&amp;</span><span class="ident">str</span>) <span class="op">-</span><span class="op">&gt;</span> <span class="kw-2">&amp;</span><span class="kw-2">mut</span> <span class="self">Self</span> {
<span class="ident">append_key_only</span>(
<span class="ident">string</span>(<span class="kw-2">&amp;</span><span class="kw-2">mut</span> <span class="self">self</span>.<span class="ident">target</span>),
<span class="self">self</span>.<span class="ident">start_position</span>,
<span class="self">self</span>.<span class="ident">encoding</span>,
<span class="ident">name</span>,
);
<span class="self">self</span>
}
<span class="doccomment">/// Serialize and append a number of name/value pairs.</span>
<span class="doccomment">///</span>
<span class="doccomment">/// This simply calls `append_pair` repeatedly.</span>
<span class="doccomment">/// This can be more convenient, so the user doesnt need to introduce a block</span>
<span class="doccomment">/// to limit the scope of `Serializer`s borrow of its string.</span>
<span class="doccomment">///</span>
<span class="doccomment">/// Panics if called after `.finish()`.</span>
<span class="kw">pub</span> <span class="kw">fn</span> <span class="ident">extend_pairs</span><span class="op">&lt;</span><span class="ident">I</span>, <span class="ident">K</span>, <span class="ident">V</span><span class="op">&gt;</span>(<span class="kw-2">&amp;</span><span class="kw-2">mut</span> <span class="self">self</span>, <span class="ident">iter</span>: <span class="ident">I</span>) <span class="op">-</span><span class="op">&gt;</span> <span class="kw-2">&amp;</span><span class="kw-2">mut</span> <span class="self">Self</span>
<span class="kw">where</span>
<span class="ident">I</span>: <span class="ident">IntoIterator</span>,
<span class="ident">I</span>::<span class="ident">Item</span>: <span class="ident">Borrow</span><span class="op">&lt;</span>(<span class="ident">K</span>, <span class="ident">V</span>)<span class="op">&gt;</span>,
<span class="ident">K</span>: <span class="ident">AsRef</span><span class="op">&lt;</span><span class="ident">str</span><span class="op">&gt;</span>,
<span class="ident">V</span>: <span class="ident">AsRef</span><span class="op">&lt;</span><span class="ident">str</span><span class="op">&gt;</span>,
{
{
<span class="kw">let</span> <span class="ident">string</span> <span class="op">=</span> <span class="ident">string</span>(<span class="kw-2">&amp;</span><span class="kw-2">mut</span> <span class="self">self</span>.<span class="ident">target</span>);
<span class="kw">for</span> <span class="ident">pair</span> <span class="kw">in</span> <span class="ident">iter</span> {
<span class="kw">let</span> <span class="kw-2">&amp;</span>(<span class="kw-2">ref</span> <span class="ident">k</span>, <span class="kw-2">ref</span> <span class="ident">v</span>) <span class="op">=</span> <span class="ident">pair</span>.<span class="ident">borrow</span>();
<span class="ident">append_pair</span>(
<span class="ident">string</span>,
<span class="self">self</span>.<span class="ident">start_position</span>,
<span class="self">self</span>.<span class="ident">encoding</span>,
<span class="ident">k</span>.<span class="ident">as_ref</span>(),
<span class="ident">v</span>.<span class="ident">as_ref</span>(),
);
}
}
<span class="self">self</span>
}
<span class="doccomment">/// Serialize and append a number of names without values.</span>
<span class="doccomment">///</span>
<span class="doccomment">/// This simply calls `append_key_only` repeatedly.</span>
<span class="doccomment">/// This can be more convenient, so the user doesnt need to introduce a block</span>
<span class="doccomment">/// to limit the scope of `Serializer`s borrow of its string.</span>
<span class="doccomment">///</span>
<span class="doccomment">/// Panics if called after `.finish()`.</span>
<span class="kw">pub</span> <span class="kw">fn</span> <span class="ident">extend_keys_only</span><span class="op">&lt;</span><span class="ident">I</span>, <span class="ident">K</span><span class="op">&gt;</span>(<span class="kw-2">&amp;</span><span class="kw-2">mut</span> <span class="self">self</span>, <span class="ident">iter</span>: <span class="ident">I</span>) <span class="op">-</span><span class="op">&gt;</span> <span class="kw-2">&amp;</span><span class="kw-2">mut</span> <span class="self">Self</span>
<span class="kw">where</span>
<span class="ident">I</span>: <span class="ident">IntoIterator</span>,
<span class="ident">I</span>::<span class="ident">Item</span>: <span class="ident">Borrow</span><span class="op">&lt;</span><span class="ident">K</span><span class="op">&gt;</span>,
<span class="ident">K</span>: <span class="ident">AsRef</span><span class="op">&lt;</span><span class="ident">str</span><span class="op">&gt;</span>,
{
{
<span class="kw">let</span> <span class="ident">string</span> <span class="op">=</span> <span class="ident">string</span>(<span class="kw-2">&amp;</span><span class="kw-2">mut</span> <span class="self">self</span>.<span class="ident">target</span>);
<span class="kw">for</span> <span class="ident">key</span> <span class="kw">in</span> <span class="ident">iter</span> {
<span class="kw">let</span> <span class="ident">k</span> <span class="op">=</span> <span class="ident">key</span>.<span class="ident">borrow</span>().<span class="ident">as_ref</span>();
<span class="ident">append_key_only</span>(<span class="ident">string</span>, <span class="self">self</span>.<span class="ident">start_position</span>, <span class="self">self</span>.<span class="ident">encoding</span>, <span class="ident">k</span>);
}
}
<span class="self">self</span>
}
<span class="doccomment">/// If this serializer was constructed with a string, take and return that string.</span>
<span class="doccomment">///</span>
<span class="doccomment">/// ```rust</span>
<span class="doccomment">/// use form_urlencoded;</span>
<span class="doccomment">/// let encoded: String = form_urlencoded::Serializer::new(String::new())</span>
<span class="doccomment">/// .append_pair(&quot;foo&quot;, &quot;bar &amp; baz&quot;)</span>
<span class="doccomment">/// .append_pair(&quot;saison&quot;, &quot;Été+hiver&quot;)</span>
<span class="doccomment">/// .finish();</span>
<span class="doccomment">/// assert_eq!(encoded, &quot;foo=bar+%26+baz&amp;saison=%C3%89t%C3%A9%2Bhiver&quot;);</span>
<span class="doccomment">/// ```</span>
<span class="doccomment">///</span>
<span class="doccomment">/// Panics if called more than once.</span>
<span class="kw">pub</span> <span class="kw">fn</span> <span class="ident">finish</span>(<span class="kw-2">&amp;</span><span class="kw-2">mut</span> <span class="self">self</span>) <span class="op">-</span><span class="op">&gt;</span> <span class="ident">T</span>::<span class="ident">Finished</span> {
<span class="self">self</span>.<span class="ident">target</span>
.<span class="ident">take</span>()
.<span class="ident">expect</span>(<span class="string">&quot;url::form_urlencoded::Serializer double finish&quot;</span>)
.<span class="ident">finish</span>()
}
}
<span class="kw">fn</span> <span class="ident">append_separator_if_needed</span>(<span class="ident">string</span>: <span class="kw-2">&amp;</span><span class="kw-2">mut</span> <span class="ident">String</span>, <span class="ident">start_position</span>: <span class="ident">usize</span>) {
<span class="kw">if</span> <span class="ident">string</span>.<span class="ident">len</span>() <span class="op">&gt;</span> <span class="ident">start_position</span> {
<span class="ident">string</span>.<span class="ident">push</span>(<span class="string">&#39;&amp;&#39;</span>)
}
}
<span class="kw">fn</span> <span class="ident">string</span><span class="op">&lt;</span><span class="ident">T</span>: <span class="ident">Target</span><span class="op">&gt;</span>(<span class="ident">target</span>: <span class="kw-2">&amp;</span><span class="kw-2">mut</span> <span class="prelude-ty">Option</span><span class="op">&lt;</span><span class="ident">T</span><span class="op">&gt;</span>) <span class="op">-</span><span class="op">&gt;</span> <span class="kw-2">&amp;</span><span class="kw-2">mut</span> <span class="ident">String</span> {
<span class="ident">target</span>
.<span class="ident">as_mut</span>()
.<span class="ident">expect</span>(<span class="string">&quot;url::form_urlencoded::Serializer finished&quot;</span>)
.<span class="ident">as_mut_string</span>()
}
<span class="kw">fn</span> <span class="ident">append_pair</span>(
<span class="ident">string</span>: <span class="kw-2">&amp;</span><span class="kw-2">mut</span> <span class="ident">String</span>,
<span class="ident">start_position</span>: <span class="ident">usize</span>,
<span class="ident">encoding</span>: <span class="ident">EncodingOverride</span><span class="op">&lt;</span><span class="lifetime">&#39;_</span><span class="op">&gt;</span>,
<span class="ident">name</span>: <span class="kw-2">&amp;</span><span class="ident">str</span>,
<span class="ident">value</span>: <span class="kw-2">&amp;</span><span class="ident">str</span>,
) {
<span class="ident">append_separator_if_needed</span>(<span class="ident">string</span>, <span class="ident">start_position</span>);
<span class="ident">append_encoded</span>(<span class="ident">name</span>, <span class="ident">string</span>, <span class="ident">encoding</span>);
<span class="ident">string</span>.<span class="ident">push</span>(<span class="string">&#39;=&#39;</span>);
<span class="ident">append_encoded</span>(<span class="ident">value</span>, <span class="ident">string</span>, <span class="ident">encoding</span>);
}
<span class="kw">fn</span> <span class="ident">append_key_only</span>(
<span class="ident">string</span>: <span class="kw-2">&amp;</span><span class="kw-2">mut</span> <span class="ident">String</span>,
<span class="ident">start_position</span>: <span class="ident">usize</span>,
<span class="ident">encoding</span>: <span class="ident">EncodingOverride</span>,
<span class="ident">name</span>: <span class="kw-2">&amp;</span><span class="ident">str</span>,
) {
<span class="ident">append_separator_if_needed</span>(<span class="ident">string</span>, <span class="ident">start_position</span>);
<span class="ident">append_encoded</span>(<span class="ident">name</span>, <span class="ident">string</span>, <span class="ident">encoding</span>);
}
<span class="kw">fn</span> <span class="ident">append_encoded</span>(<span class="ident">s</span>: <span class="kw-2">&amp;</span><span class="ident">str</span>, <span class="ident">string</span>: <span class="kw-2">&amp;</span><span class="kw-2">mut</span> <span class="ident">String</span>, <span class="ident">encoding</span>: <span class="ident">EncodingOverride</span><span class="op">&lt;</span><span class="lifetime">&#39;_</span><span class="op">&gt;</span>) {
<span class="ident">string</span>.<span class="ident">extend</span>(<span class="ident">byte_serialize</span>(<span class="kw-2">&amp;</span><span class="ident">encode</span>(<span class="ident">encoding</span>, <span class="ident">s</span>)))
}
<span class="kw">pub</span>(<span class="kw">crate</span>) <span class="kw">fn</span> <span class="ident">encode</span><span class="op">&lt;</span><span class="lifetime">&#39;a</span><span class="op">&gt;</span>(<span class="ident">encoding_override</span>: <span class="ident">EncodingOverride</span><span class="op">&lt;</span><span class="lifetime">&#39;_</span><span class="op">&gt;</span>, <span class="ident">input</span>: <span class="kw-2">&amp;</span><span class="lifetime">&#39;a</span> <span class="ident">str</span>) <span class="op">-</span><span class="op">&gt;</span> <span class="ident">Cow</span><span class="op">&lt;</span><span class="lifetime">&#39;a</span>, [<span class="ident">u8</span>]<span class="op">&gt;</span> {
<span class="kw">if</span> <span class="kw">let</span> <span class="prelude-val">Some</span>(<span class="ident">o</span>) <span class="op">=</span> <span class="ident">encoding_override</span> {
<span class="kw">return</span> <span class="ident">o</span>(<span class="ident">input</span>);
}
<span class="ident">input</span>.<span class="ident">as_bytes</span>().<span class="ident">into</span>()
}
<span class="kw">pub</span>(<span class="kw">crate</span>) <span class="kw">fn</span> <span class="ident">decode_utf8_lossy</span>(<span class="ident">input</span>: <span class="ident">Cow</span><span class="op">&lt;</span><span class="lifetime">&#39;_</span>, [<span class="ident">u8</span>]<span class="op">&gt;</span>) <span class="op">-</span><span class="op">&gt;</span> <span class="ident">Cow</span><span class="op">&lt;</span><span class="lifetime">&#39;_</span>, <span class="ident">str</span><span class="op">&gt;</span> {
<span class="comment">// Note: This function is duplicated in `percent_encoding/lib.rs`.</span>
<span class="kw">match</span> <span class="ident">input</span> {
<span class="ident">Cow</span>::<span class="ident">Borrowed</span>(<span class="ident">bytes</span>) <span class="op">=</span><span class="op">&gt;</span> <span class="ident">String</span>::<span class="ident">from_utf8_lossy</span>(<span class="ident">bytes</span>),
<span class="ident">Cow</span>::<span class="ident">Owned</span>(<span class="ident">bytes</span>) <span class="op">=</span><span class="op">&gt;</span> {
<span class="kw">match</span> <span class="ident">String</span>::<span class="ident">from_utf8_lossy</span>(<span class="kw-2">&amp;</span><span class="ident">bytes</span>) {
<span class="ident">Cow</span>::<span class="ident">Borrowed</span>(<span class="ident">utf8</span>) <span class="op">=</span><span class="op">&gt;</span> {
<span class="comment">// If from_utf8_lossy returns a Cow::Borrowed, then we can</span>
<span class="comment">// be sure our original bytes were valid UTF-8. This is because</span>
<span class="comment">// if the bytes were invalid UTF-8 from_utf8_lossy would have</span>
<span class="comment">// to allocate a new owned string to back the Cow so it could</span>
<span class="comment">// replace invalid bytes with a placeholder.</span>
<span class="comment">// First we do a debug_assert to confirm our description above.</span>
<span class="kw">let</span> <span class="ident">raw_utf8</span>: <span class="kw-2">*</span><span class="kw">const</span> [<span class="ident">u8</span>];
<span class="ident">raw_utf8</span> <span class="op">=</span> <span class="ident">utf8</span>.<span class="ident">as_bytes</span>();
<span class="macro">debug_assert</span><span class="macro">!</span>(<span class="ident">raw_utf8</span> <span class="op">=</span><span class="op">=</span> <span class="kw-2">&amp;</span><span class="kw-2">*</span><span class="ident">bytes</span> <span class="kw">as</span> <span class="kw-2">*</span><span class="kw">const</span> [<span class="ident">u8</span>]);
<span class="comment">// Given we know the original input bytes are valid UTF-8,</span>
<span class="comment">// and we have ownership of those bytes, we re-use them and</span>
<span class="comment">// return a Cow::Owned here.</span>
<span class="ident">Cow</span>::<span class="ident">Owned</span>(<span class="kw">unsafe</span> { <span class="ident">String</span>::<span class="ident">from_utf8_unchecked</span>(<span class="ident">bytes</span>) })
}
<span class="ident">Cow</span>::<span class="ident">Owned</span>(<span class="ident">s</span>) <span class="op">=</span><span class="op">&gt;</span> <span class="ident">Cow</span>::<span class="ident">Owned</span>(<span class="ident">s</span>),
}
}
}
}
<span class="kw">pub</span> <span class="kw">type</span> <span class="ident">EncodingOverride</span><span class="op">&lt;</span><span class="lifetime">&#39;a</span><span class="op">&gt;</span> <span class="op">=</span> <span class="prelude-ty">Option</span><span class="op">&lt;</span><span class="kw-2">&amp;</span><span class="lifetime">&#39;a</span> <span class="kw">dyn</span> <span class="ident">Fn</span>(<span class="kw-2">&amp;</span><span class="ident">str</span>) <span class="op">-</span><span class="op">&gt;</span> <span class="ident">Cow</span><span class="op">&lt;</span><span class="lifetime">&#39;_</span>, [<span class="ident">u8</span>]<span class="op">&gt;</span><span class="op">&gt;</span>;
</pre></div>
</section><section id="search" class="content hidden"></section><section class="footer"></section><div id="rustdoc-vars" data-root-path="../../" data-current-crate="form_urlencoded"></div>
<script src="../../main.js"></script><script src="../../source-script.js"></script><script src="../../source-files.js"></script><script defer src="../../search-index.js"></script></body></html>