OMGeeky/google-apis-rs
1
0
Fork 0
mirror of https://github.com/OMGeeky/google-apis-rs.git synced 2026-01-25 12:44:07 +01:00
Code Issues Packages Projects Releases Wiki Activity
Files
37ba635de2b0340299e6a35431c2efd0ca3aa555
google-apis-rs/bytes/buf/trait.BufMut.html
Sebastian Thiel 37ba635de2 Update documentation
2021-04-02 00:20:57 +08:00

550 lines
98 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="API documentation for the Rust `BufMut` trait in crate `bytes`."><meta name="keywords" content="rust, rustlang, rust-lang, BufMut"><title>bytes::buf::BufMut - Rust</title><link rel="stylesheet" type="text/css" href="../../normalize.css"><link rel="stylesheet" type="text/css" href="../../rustdoc.css" id="mainThemeStyle"><link rel="stylesheet" type="text/css" href="../../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 trait"><!--[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='../../bytes/index.html'><div class='logo-container rust-logo'><img src='../../rust-logo.png' alt='logo'></div></a><p class="location">Trait BufMut</p><div class="sidebar-elems"><div class="block items"><a class="sidebar-title" href="#required-methods">Required Methods</a><div class="sidebar-links"><a href="#tymethod.remaining_mut">remaining_mut</a><a href="#tymethod.advance_mut">advance_mut</a><a href="#tymethod.chunk_mut">chunk_mut</a></div><a class="sidebar-title" href="#provided-methods">Provided Methods</a><div class="sidebar-links"><a href="#method.limit">limit</a><a href="#method.writer">writer</a><a href="#method.put">put</a><a href="#method.has_remaining_mut">has_remaining_mut</a><a href="#method.put_slice">put_slice</a><a href="#method.put_u8">put_u8</a><a href="#method.put_i8">put_i8</a><a href="#method.put_u16">put_u16</a><a href="#method.put_u16_le">put_u16_le</a><a href="#method.put_i16">put_i16</a><a href="#method.put_i16_le">put_i16_le</a><a href="#method.put_u32">put_u32</a><a href="#method.put_u32_le">put_u32_le</a><a href="#method.put_i32">put_i32</a><a href="#method.put_i32_le">put_i32_le</a><a href="#method.put_u64">put_u64</a><a href="#method.put_u64_le">put_u64_le</a><a href="#method.put_i64">put_i64</a><a href="#method.put_i64_le">put_i64_le</a><a href="#method.put_u128">put_u128</a><a href="#method.put_u128_le">put_u128_le</a><a href="#method.put_i128">put_i128</a><a href="#method.put_i128_le">put_i128_le</a><a href="#method.put_uint">put_uint</a><a href="#method.put_uint_le">put_uint_le</a><a href="#method.put_int">put_int</a><a href="#method.put_int_le">put_int_le</a><a href="#method.put_f32">put_f32</a><a href="#method.put_f32_le">put_f32_le</a><a href="#method.put_f64">put_f64</a><a href="#method.put_f64_le">put_f64_le</a><a href="#method.chain_mut">chain_mut</a></div><a class="sidebar-title" href="#foreign-impls">Implementations on Foreign Types</a><div class="sidebar-links"><a href="#impl-BufMut-for-%26mut%20T">&amp;mut T</a><a href="#impl-BufMut-for-%26mut%20%5Bu8%5D">&amp;mut [u8]</a><a href="#impl-BufMut-for-Box%3CT%3E">Box&lt;T&gt;</a><a href="#impl-BufMut-for-Vec%3Cu8%3E">Vec&lt;u8&gt;</a></div><a class="sidebar-title" href="#implementors">Implementors</a></div><p class="location"><a href="../index.html">bytes</a>::<wbr><a href="index.html">buf</a></p><div id="sidebar-vars" data-name="BufMut" data-ty="trait" data-relpath=""></div><script defer src="sidebar-items.js"></script></div></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"><h1 class="fqn"><span class="in-band">Trait <a href="../index.html">bytes</a>::<wbr><a href="index.html">buf</a>::<wbr><a class="trait" href="">BufMut</a></span><span class="out-of-band"><span id="render-detail"><a id="toggle-all-docs" href="javascript:void(0)" title="collapse all docs">[<span class="inner">&#x2212;</span>]</a></span><a class="srclink" href="../../src/bytes/buf/buf_mut.rs.html#29-908" title="goto source code">[src]</a></span></h1><div class="docblock type-decl hidden-by-usual-hider"><pre class="rust trait">pub unsafe trait BufMut {
fn <a href="#tymethod.remaining_mut" class="fnname">remaining_mut</a>(&amp;self) -&gt; <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.usize.html">usize</a>;
<div class="item-spacer"></div> unsafe fn <a href="#tymethod.advance_mut" class="fnname">advance_mut</a>(&amp;mut self, cnt: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.usize.html">usize</a>);
<div class="item-spacer"></div> fn <a href="#tymethod.chunk_mut" class="fnname">chunk_mut</a>(&amp;mut self) -&gt; &amp;mut <a class="struct" href="../../bytes/buf/struct.UninitSlice.html" title="struct bytes::buf::UninitSlice">UninitSlice</a>;
fn <a href="#method.has_remaining_mut" class="fnname">has_remaining_mut</a>(&amp;self) -&gt; <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.bool.html">bool</a> { ... }
<div class="item-spacer"></div> fn <a href="#method.put" class="fnname">put</a>&lt;T:&nbsp;<a class="trait" href="../../bytes/buf/trait.Buf.html" title="trait bytes::buf::Buf">Buf</a>&gt;(&amp;mut self, src: T)<br>&nbsp;&nbsp;&nbsp; <span class="where">where<br>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Self: <a class="trait" href="https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html" title="trait core::marker::Sized">Sized</a></span>,
{ ... }
<div class="item-spacer"></div> fn <a href="#method.put_slice" class="fnname">put_slice</a>(&amp;mut self, src: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.slice.html">&amp;[</a><a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.u8.html">u8</a><a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.slice.html">]</a>) { ... }
<div class="item-spacer"></div> fn <a href="#method.put_u8" class="fnname">put_u8</a>(&amp;mut self, n: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.u8.html">u8</a>) { ... }
<div class="item-spacer"></div> fn <a href="#method.put_i8" class="fnname">put_i8</a>(&amp;mut self, n: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.i8.html">i8</a>) { ... }
<div class="item-spacer"></div> fn <a href="#method.put_u16" class="fnname">put_u16</a>(&amp;mut self, n: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.u16.html">u16</a>) { ... }
<div class="item-spacer"></div> fn <a href="#method.put_u16_le" class="fnname">put_u16_le</a>(&amp;mut self, n: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.u16.html">u16</a>) { ... }
<div class="item-spacer"></div> fn <a href="#method.put_i16" class="fnname">put_i16</a>(&amp;mut self, n: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.i16.html">i16</a>) { ... }
<div class="item-spacer"></div> fn <a href="#method.put_i16_le" class="fnname">put_i16_le</a>(&amp;mut self, n: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.i16.html">i16</a>) { ... }
<div class="item-spacer"></div> fn <a href="#method.put_u32" class="fnname">put_u32</a>(&amp;mut self, n: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.u32.html">u32</a>) { ... }
<div class="item-spacer"></div> fn <a href="#method.put_u32_le" class="fnname">put_u32_le</a>(&amp;mut self, n: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.u32.html">u32</a>) { ... }
<div class="item-spacer"></div> fn <a href="#method.put_i32" class="fnname">put_i32</a>(&amp;mut self, n: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.i32.html">i32</a>) { ... }
<div class="item-spacer"></div> fn <a href="#method.put_i32_le" class="fnname">put_i32_le</a>(&amp;mut self, n: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.i32.html">i32</a>) { ... }
<div class="item-spacer"></div> fn <a href="#method.put_u64" class="fnname">put_u64</a>(&amp;mut self, n: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.u64.html">u64</a>) { ... }
<div class="item-spacer"></div> fn <a href="#method.put_u64_le" class="fnname">put_u64_le</a>(&amp;mut self, n: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.u64.html">u64</a>) { ... }
<div class="item-spacer"></div> fn <a href="#method.put_i64" class="fnname">put_i64</a>(&amp;mut self, n: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.i64.html">i64</a>) { ... }
<div class="item-spacer"></div> fn <a href="#method.put_i64_le" class="fnname">put_i64_le</a>(&amp;mut self, n: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.i64.html">i64</a>) { ... }
<div class="item-spacer"></div> fn <a href="#method.put_u128" class="fnname">put_u128</a>(&amp;mut self, n: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.u128.html">u128</a>) { ... }
<div class="item-spacer"></div> fn <a href="#method.put_u128_le" class="fnname">put_u128_le</a>(&amp;mut self, n: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.u128.html">u128</a>) { ... }
<div class="item-spacer"></div> fn <a href="#method.put_i128" class="fnname">put_i128</a>(&amp;mut self, n: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.i128.html">i128</a>) { ... }
<div class="item-spacer"></div> fn <a href="#method.put_i128_le" class="fnname">put_i128_le</a>(&amp;mut self, n: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.i128.html">i128</a>) { ... }
<div class="item-spacer"></div> fn <a href="#method.put_uint" class="fnname">put_uint</a>(&amp;mut self, n: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.u64.html">u64</a>, nbytes: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.usize.html">usize</a>) { ... }
<div class="item-spacer"></div> fn <a href="#method.put_uint_le" class="fnname">put_uint_le</a>(&amp;mut self, n: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.u64.html">u64</a>, nbytes: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.usize.html">usize</a>) { ... }
<div class="item-spacer"></div> fn <a href="#method.put_int" class="fnname">put_int</a>(&amp;mut self, n: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.i64.html">i64</a>, nbytes: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.usize.html">usize</a>) { ... }
<div class="item-spacer"></div> fn <a href="#method.put_int_le" class="fnname">put_int_le</a>(&amp;mut self, n: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.i64.html">i64</a>, nbytes: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.usize.html">usize</a>) { ... }
<div class="item-spacer"></div> fn <a href="#method.put_f32" class="fnname">put_f32</a>(&amp;mut self, n: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.f32.html">f32</a>) { ... }
<div class="item-spacer"></div> fn <a href="#method.put_f32_le" class="fnname">put_f32_le</a>(&amp;mut self, n: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.f32.html">f32</a>) { ... }
<div class="item-spacer"></div> fn <a href="#method.put_f64" class="fnname">put_f64</a>(&amp;mut self, n: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.f64.html">f64</a>) { ... }
<div class="item-spacer"></div> fn <a href="#method.put_f64_le" class="fnname">put_f64_le</a>(&amp;mut self, n: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.f64.html">f64</a>) { ... }
<div class="item-spacer"></div> fn <a href="#method.limit" class="fnname">limit</a>(self, limit: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.usize.html">usize</a>) -&gt; <a class="struct" href="../../bytes/buf/struct.Limit.html" title="struct bytes::buf::Limit">Limit</a>&lt;Self&gt;<br>&nbsp;&nbsp;&nbsp; <span class="where">where<br>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Self: <a class="trait" href="https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html" title="trait core::marker::Sized">Sized</a></span>,
{ ... }
<div class="item-spacer"></div> fn <a href="#method.writer" class="fnname">writer</a>(self) -&gt; <a class="struct" href="../../bytes/buf/struct.Writer.html" title="struct bytes::buf::Writer">Writer</a>&lt;Self&gt;<span class="notable-traits"><span class="notable-traits-tooltip">ⓘ<div class="notable-traits-tooltiptext"><span class="docblock"><h3 class="notable">Notable traits for <a class="struct" href="../../bytes/buf/struct.Writer.html" title="struct bytes::buf::Writer">Writer</a>&lt;B&gt;</h3><code class="content"><span class="where fmt-newline">impl&lt;B:&nbsp;<a class="trait" href="../../bytes/buf/trait.BufMut.html" title="trait bytes::buf::BufMut">BufMut</a> + <a class="trait" href="https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html" title="trait core::marker::Sized">Sized</a>&gt; <a class="trait" href="https://doc.rust-lang.org/nightly/std/io/trait.Write.html" title="trait std::io::Write">Write</a> for <a class="struct" href="../../bytes/buf/struct.Writer.html" title="struct bytes::buf::Writer">Writer</a>&lt;B&gt;</span></code></span></div></span></span><br>&nbsp;&nbsp;&nbsp; <span class="where">where<br>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Self: <a class="trait" href="https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html" title="trait core::marker::Sized">Sized</a></span>,
{ ... }
<div class="item-spacer"></div> fn <a href="#method.chain_mut" class="fnname">chain_mut</a>&lt;U:&nbsp;<a class="trait" href="../../bytes/buf/trait.BufMut.html" title="trait bytes::buf::BufMut">BufMut</a>&gt;(self, next: U) -&gt; <a class="struct" href="../../bytes/buf/struct.Chain.html" title="struct bytes::buf::Chain">Chain</a>&lt;Self, U&gt;<br>&nbsp;&nbsp;&nbsp; <span class="where">where<br>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Self: <a class="trait" href="https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html" title="trait core::marker::Sized">Sized</a></span>,
{ ... }
}</pre></div><div class="docblock"><p>A trait for values that provide sequential write access to bytes.</p>
<p>Write bytes to a buffer</p>
<p>A buffer stores bytes in memory such that write operations are infallible.
The underlying storage may or may not be in contiguous memory. A <code>BufMut</code>
value is a cursor into the buffer. Writing to <code>BufMut</code> advances the cursor
position.</p>
<p>The simplest <code>BufMut</code> is a <code>Vec&lt;u8&gt;</code>.</p>
<div class="example-wrap"><pre class="rust rust-example-rendered">
<span class="kw">use</span> <span class="ident">bytes</span>::<span class="ident">BufMut</span>;
<span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">buf</span> <span class="op">=</span> <span class="macro">vec</span><span class="macro">!</span>[];
<span class="ident">buf</span>.<span class="ident">put</span>(<span class="kw-2">&amp;</span><span class="string">b&quot;hello world&quot;</span>[..]);
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">buf</span>, <span class="string">b&quot;hello world&quot;</span>);</pre></div>
</div><h2 id="required-methods" class="small-section-header">Required methods<a href="#required-methods" class="anchor"></a></h2><div class="methods"><h3 id="tymethod.remaining_mut" class="method"><code>fn <a href="#tymethod.remaining_mut" class="fnname">remaining_mut</a>(&amp;self) -&gt; <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.usize.html">usize</a></code><a class="srclink" href="../../src/bytes/buf/buf_mut.rs.html#55" title="goto source code">[src]</a></h3><div class="docblock"><p>Returns the number of bytes that can be written from the current
position until the end of the buffer is reached.</p>
<p>This value is greater than or equal to the length of the slice returned
by <code>chunk_mut()</code>.</p>
<h1 id="examples" class="section-header"><a href="#examples">Examples</a></h1>
<div class="example-wrap"><pre class="rust rust-example-rendered">
<span class="kw">use</span> <span class="ident">bytes</span>::<span class="ident">BufMut</span>;
<span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">dst</span> <span class="op">=</span> [<span class="number">0</span>; <span class="number">10</span>];
<span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">buf</span> <span class="op">=</span> <span class="kw-2">&amp;</span><span class="kw-2">mut</span> <span class="ident">dst</span>[..];
<span class="kw">let</span> <span class="ident">original_remaining</span> <span class="op">=</span> <span class="ident">buf</span>.<span class="ident">remaining_mut</span>();
<span class="ident">buf</span>.<span class="ident">put</span>(<span class="kw-2">&amp;</span><span class="string">b&quot;hello&quot;</span>[..]);
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">original_remaining</span> <span class="op">-</span> <span class="number">5</span>, <span class="ident">buf</span>.<span class="ident">remaining_mut</span>());</pre></div>
<h1 id="implementer-notes" class="section-header"><a href="#implementer-notes">Implementer notes</a></h1>
<p>Implementations of <code>remaining_mut</code> should ensure that the return value
does not change unless a call is made to <code>advance_mut</code> or any other
function that is documented to change the <code>BufMut</code>'s current position.</p>
</div><h3 id="tymethod.advance_mut" class="method"><code>unsafe fn <a href="#tymethod.advance_mut" class="fnname">advance_mut</a>(&amp;mut self, cnt: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.usize.html">usize</a>)</code><a class="srclink" href="../../src/bytes/buf/buf_mut.rs.html#96" title="goto source code">[src]</a></h3><div class="docblock"><p>Advance the internal cursor of the BufMut</p>
<p>The next call to <code>chunk_mut</code> will return a slice starting <code>cnt</code> bytes
further into the underlying buffer.</p>
<p>This function is unsafe because there is no guarantee that the bytes
being advanced past have been initialized.</p>
<h1 id="examples-1" class="section-header"><a href="#examples-1">Examples</a></h1>
<div class="example-wrap"><pre class="rust rust-example-rendered">
<span class="kw">use</span> <span class="ident">bytes</span>::<span class="ident">BufMut</span>;
<span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">buf</span> <span class="op">=</span> <span class="ident">Vec</span>::<span class="ident">with_capacity</span>(<span class="number">16</span>);
<span class="comment">// Write some data</span>
<span class="ident">buf</span>.<span class="ident">chunk_mut</span>()[<span class="number">0</span>..<span class="number">2</span>].<span class="ident">copy_from_slice</span>(<span class="string">b&quot;he&quot;</span>);
<span class="kw">unsafe</span> { <span class="ident">buf</span>.<span class="ident">advance_mut</span>(<span class="number">2</span>) };
<span class="comment">// write more bytes</span>
<span class="ident">buf</span>.<span class="ident">chunk_mut</span>()[<span class="number">0</span>..<span class="number">3</span>].<span class="ident">copy_from_slice</span>(<span class="string">b&quot;llo&quot;</span>);
<span class="kw">unsafe</span> { <span class="ident">buf</span>.<span class="ident">advance_mut</span>(<span class="number">3</span>); }
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="number">5</span>, <span class="ident">buf</span>.<span class="ident">len</span>());
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">buf</span>, <span class="string">b&quot;hello&quot;</span>);</pre></div>
<h1 id="panics" class="section-header"><a href="#panics">Panics</a></h1>
<p>This function <strong>may</strong> panic if <code>cnt &gt; self.remaining_mut()</code>.</p>
<h1 id="implementer-notes-1" class="section-header"><a href="#implementer-notes-1">Implementer notes</a></h1>
<p>It is recommended for implementations of <code>advance_mut</code> to panic if
<code>cnt &gt; self.remaining_mut()</code>. If the implementation does not panic,
the call must behave as if <code>cnt == self.remaining_mut()</code>.</p>
<p>A call with <code>cnt == 0</code> should never panic and be a no-op.</p>
</div><h3 id="tymethod.chunk_mut" class="method"><code>fn <a href="#tymethod.chunk_mut" class="fnname">chunk_mut</a>(&amp;mut self) -&gt; &amp;mut <a class="struct" href="../../bytes/buf/struct.UninitSlice.html" title="struct bytes::buf::UninitSlice">UninitSlice</a></code><a class="srclink" href="../../src/bytes/buf/buf_mut.rs.html#161" title="goto source code">[src]</a></h3><div class="docblock"><p>Returns a mutable slice starting at the current BufMut position and of
length between 0 and <code>BufMut::remaining_mut()</code>. Note that this <em>can</em> be shorter than the
whole remainder of the buffer (this allows non-continuous implementation).</p>
<p>This is a lower level function. Most operations are done with other
functions.</p>
<p>The returned byte slice may represent uninitialized memory.</p>
<h1 id="examples-2" class="section-header"><a href="#examples-2">Examples</a></h1>
<div class="example-wrap"><pre class="rust rust-example-rendered">
<span class="kw">use</span> <span class="ident">bytes</span>::<span class="ident">BufMut</span>;
<span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">buf</span> <span class="op">=</span> <span class="ident">Vec</span>::<span class="ident">with_capacity</span>(<span class="number">16</span>);
<span class="kw">unsafe</span> {
<span class="comment">// MaybeUninit::as_mut_ptr</span>
<span class="ident">buf</span>.<span class="ident">chunk_mut</span>()[<span class="number">0</span>..].<span class="ident">as_mut_ptr</span>().<span class="ident">write</span>(<span class="string">b&#39;h&#39;</span>);
<span class="ident">buf</span>.<span class="ident">chunk_mut</span>()[<span class="number">1</span>..].<span class="ident">as_mut_ptr</span>().<span class="ident">write</span>(<span class="string">b&#39;e&#39;</span>);
<span class="ident">buf</span>.<span class="ident">advance_mut</span>(<span class="number">2</span>);
<span class="ident">buf</span>.<span class="ident">chunk_mut</span>()[<span class="number">0</span>..].<span class="ident">as_mut_ptr</span>().<span class="ident">write</span>(<span class="string">b&#39;l&#39;</span>);
<span class="ident">buf</span>.<span class="ident">chunk_mut</span>()[<span class="number">1</span>..].<span class="ident">as_mut_ptr</span>().<span class="ident">write</span>(<span class="string">b&#39;l&#39;</span>);
<span class="ident">buf</span>.<span class="ident">chunk_mut</span>()[<span class="number">2</span>..].<span class="ident">as_mut_ptr</span>().<span class="ident">write</span>(<span class="string">b&#39;o&#39;</span>);
<span class="ident">buf</span>.<span class="ident">advance_mut</span>(<span class="number">3</span>);
}
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="number">5</span>, <span class="ident">buf</span>.<span class="ident">len</span>());
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">buf</span>, <span class="string">b&quot;hello&quot;</span>);</pre></div>
<h1 id="implementer-notes-2" class="section-header"><a href="#implementer-notes-2">Implementer notes</a></h1>
<p>This function should never panic. <code>chunk_mut</code> should return an empty
slice <strong>if and only if</strong> <code>remaining_mut()</code> returns 0. In other words,
<code>chunk_mut()</code> returning an empty slice implies that <code>remaining_mut()</code> will
return 0 and <code>remaining_mut()</code> returning 0 implies that <code>chunk_mut()</code> will
return an empty slice.</p>
</div></div><span class="loading-content">Loading content...</span><h2 id="provided-methods" class="small-section-header">Provided methods<a href="#provided-methods" class="anchor"></a></h2><div class="methods"><h3 id="method.has_remaining_mut" class="method"><code>fn <a href="#method.has_remaining_mut" class="fnname">has_remaining_mut</a>(&amp;self) -&gt; <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.bool.html">bool</a></code><a class="srclink" href="../../src/bytes/buf/buf_mut.rs.html#116-118" title="goto source code">[src]</a></h3><div class="docblock"><p>Returns true if there is space in <code>self</code> for more bytes.</p>
<p>This is equivalent to <code>self.remaining_mut() != 0</code>.</p>
<h1 id="examples-3" class="section-header"><a href="#examples-3">Examples</a></h1>
<div class="example-wrap"><pre class="rust rust-example-rendered">
<span class="kw">use</span> <span class="ident">bytes</span>::<span class="ident">BufMut</span>;
<span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">dst</span> <span class="op">=</span> [<span class="number">0</span>; <span class="number">5</span>];
<span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">buf</span> <span class="op">=</span> <span class="kw-2">&amp;</span><span class="kw-2">mut</span> <span class="ident">dst</span>[..];
<span class="macro">assert</span><span class="macro">!</span>(<span class="ident">buf</span>.<span class="ident">has_remaining_mut</span>());
<span class="ident">buf</span>.<span class="ident">put</span>(<span class="kw-2">&amp;</span><span class="string">b&quot;hello&quot;</span>[..]);
<span class="macro">assert</span><span class="macro">!</span>(<span class="op">!</span><span class="ident">buf</span>.<span class="ident">has_remaining_mut</span>());</pre></div>
</div><h3 id="method.put" class="method"><code>fn <a href="#method.put" class="fnname">put</a>&lt;T:&nbsp;<a class="trait" href="../../bytes/buf/trait.Buf.html" title="trait bytes::buf::Buf">Buf</a>&gt;(&amp;mut self, src: T) <span class="where fmt-newline">where<br>&nbsp;&nbsp;&nbsp;&nbsp;Self: <a class="trait" href="https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html" title="trait core::marker::Sized">Sized</a>,&nbsp;</span></code><a class="srclink" href="../../src/bytes/buf/buf_mut.rs.html#183-205" title="goto source code">[src]</a></h3><div class="docblock"><p>Transfer bytes into <code>self</code> from <code>src</code> and advance the cursor by the
number of bytes written.</p>
<h1 id="examples-4" class="section-header"><a href="#examples-4">Examples</a></h1>
<div class="example-wrap"><pre class="rust rust-example-rendered">
<span class="kw">use</span> <span class="ident">bytes</span>::<span class="ident">BufMut</span>;
<span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">buf</span> <span class="op">=</span> <span class="macro">vec</span><span class="macro">!</span>[];
<span class="ident">buf</span>.<span class="ident">put_u8</span>(<span class="string">b&#39;h&#39;</span>);
<span class="ident">buf</span>.<span class="ident">put</span>(<span class="kw-2">&amp;</span><span class="string">b&quot;ello&quot;</span>[..]);
<span class="ident">buf</span>.<span class="ident">put</span>(<span class="kw-2">&amp;</span><span class="string">b&quot; world&quot;</span>[..]);
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">buf</span>, <span class="string">b&quot;hello world&quot;</span>);</pre></div>
<h1 id="panics-1" class="section-header"><a href="#panics-1">Panics</a></h1>
<p>Panics if <code>self</code> does not have enough capacity to contain <code>src</code>.</p>
</div><h3 id="method.put_slice" class="method"><code>fn <a href="#method.put_slice" class="fnname">put_slice</a>(&amp;mut self, src: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.slice.html">&amp;[</a><a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.u8.html">u8</a><a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.slice.html">]</a>)</code><a class="srclink" href="../../src/bytes/buf/buf_mut.rs.html#226-252" title="goto source code">[src]</a></h3><div class="docblock"><p>Transfer bytes into <code>self</code> from <code>src</code> and advance the cursor by the
number of bytes written.</p>
<p><code>self</code> must have enough remaining capacity to contain all of <code>src</code>.</p>
<div class="example-wrap"><pre class="rust rust-example-rendered">
<span class="kw">use</span> <span class="ident">bytes</span>::<span class="ident">BufMut</span>;
<span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">dst</span> <span class="op">=</span> [<span class="number">0</span>; <span class="number">6</span>];
{
<span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">buf</span> <span class="op">=</span> <span class="kw-2">&amp;</span><span class="kw-2">mut</span> <span class="ident">dst</span>[..];
<span class="ident">buf</span>.<span class="ident">put_slice</span>(<span class="string">b&quot;hello&quot;</span>);
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="number">1</span>, <span class="ident">buf</span>.<span class="ident">remaining_mut</span>());
}
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="string">b&quot;hello\0&quot;</span>, <span class="kw-2">&amp;</span><span class="ident">dst</span>);</pre></div>
</div><h3 id="method.put_u8" class="method"><code>fn <a href="#method.put_u8" class="fnname">put_u8</a>(&amp;mut self, n: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.u8.html">u8</a>)</code><a class="srclink" href="../../src/bytes/buf/buf_mut.rs.html#272-275" title="goto source code">[src]</a></h3><div class="docblock"><p>Writes an unsigned 8 bit integer to <code>self</code>.</p>
<p>The current position is advanced by 1.</p>
<h1 id="examples-5" class="section-header"><a href="#examples-5">Examples</a></h1>
<div class="example-wrap"><pre class="rust rust-example-rendered">
<span class="kw">use</span> <span class="ident">bytes</span>::<span class="ident">BufMut</span>;
<span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">buf</span> <span class="op">=</span> <span class="macro">vec</span><span class="macro">!</span>[];
<span class="ident">buf</span>.<span class="ident">put_u8</span>(<span class="number">0x01</span>);
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">buf</span>, <span class="string">b&quot;\x01&quot;</span>);</pre></div>
<h1 id="panics-2" class="section-header"><a href="#panics-2">Panics</a></h1>
<p>This function panics if there is not enough remaining capacity in
<code>self</code>.</p>
</div><h3 id="method.put_i8" class="method"><code>fn <a href="#method.put_i8" class="fnname">put_i8</a>(&amp;mut self, n: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.i8.html">i8</a>)</code><a class="srclink" href="../../src/bytes/buf/buf_mut.rs.html#295-298" title="goto source code">[src]</a></h3><div class="docblock"><p>Writes a signed 8 bit integer to <code>self</code>.</p>
<p>The current position is advanced by 1.</p>
<h1 id="examples-6" class="section-header"><a href="#examples-6">Examples</a></h1>
<div class="example-wrap"><pre class="rust rust-example-rendered">
<span class="kw">use</span> <span class="ident">bytes</span>::<span class="ident">BufMut</span>;
<span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">buf</span> <span class="op">=</span> <span class="macro">vec</span><span class="macro">!</span>[];
<span class="ident">buf</span>.<span class="ident">put_i8</span>(<span class="number">0x01</span>);
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">buf</span>, <span class="string">b&quot;\x01&quot;</span>);</pre></div>
<h1 id="panics-3" class="section-header"><a href="#panics-3">Panics</a></h1>
<p>This function panics if there is not enough remaining capacity in
<code>self</code>.</p>
</div><h3 id="method.put_u16" class="method"><code>fn <a href="#method.put_u16" class="fnname">put_u16</a>(&amp;mut self, n: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.u16.html">u16</a>)</code><a class="srclink" href="../../src/bytes/buf/buf_mut.rs.html#318-320" title="goto source code">[src]</a></h3><div class="docblock"><p>Writes an unsigned 16 bit integer to <code>self</code> in big-endian byte order.</p>
<p>The current position is advanced by 2.</p>
<h1 id="examples-7" class="section-header"><a href="#examples-7">Examples</a></h1>
<div class="example-wrap"><pre class="rust rust-example-rendered">
<span class="kw">use</span> <span class="ident">bytes</span>::<span class="ident">BufMut</span>;
<span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">buf</span> <span class="op">=</span> <span class="macro">vec</span><span class="macro">!</span>[];
<span class="ident">buf</span>.<span class="ident">put_u16</span>(<span class="number">0x0809</span>);
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">buf</span>, <span class="string">b&quot;\x08\x09&quot;</span>);</pre></div>
<h1 id="panics-4" class="section-header"><a href="#panics-4">Panics</a></h1>
<p>This function panics if there is not enough remaining capacity in
<code>self</code>.</p>
</div><h3 id="method.put_u16_le" class="method"><code>fn <a href="#method.put_u16_le" class="fnname">put_u16_le</a>(&amp;mut self, n: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.u16.html">u16</a>)</code><a class="srclink" href="../../src/bytes/buf/buf_mut.rs.html#340-342" title="goto source code">[src]</a></h3><div class="docblock"><p>Writes an unsigned 16 bit integer to <code>self</code> in little-endian byte order.</p>
<p>The current position is advanced by 2.</p>
<h1 id="examples-8" class="section-header"><a href="#examples-8">Examples</a></h1>
<div class="example-wrap"><pre class="rust rust-example-rendered">
<span class="kw">use</span> <span class="ident">bytes</span>::<span class="ident">BufMut</span>;
<span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">buf</span> <span class="op">=</span> <span class="macro">vec</span><span class="macro">!</span>[];
<span class="ident">buf</span>.<span class="ident">put_u16_le</span>(<span class="number">0x0809</span>);
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">buf</span>, <span class="string">b&quot;\x09\x08&quot;</span>);</pre></div>
<h1 id="panics-5" class="section-header"><a href="#panics-5">Panics</a></h1>
<p>This function panics if there is not enough remaining capacity in
<code>self</code>.</p>
</div><h3 id="method.put_i16" class="method"><code>fn <a href="#method.put_i16" class="fnname">put_i16</a>(&amp;mut self, n: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.i16.html">i16</a>)</code><a class="srclink" href="../../src/bytes/buf/buf_mut.rs.html#362-364" title="goto source code">[src]</a></h3><div class="docblock"><p>Writes a signed 16 bit integer to <code>self</code> in big-endian byte order.</p>
<p>The current position is advanced by 2.</p>
<h1 id="examples-9" class="section-header"><a href="#examples-9">Examples</a></h1>
<div class="example-wrap"><pre class="rust rust-example-rendered">
<span class="kw">use</span> <span class="ident">bytes</span>::<span class="ident">BufMut</span>;
<span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">buf</span> <span class="op">=</span> <span class="macro">vec</span><span class="macro">!</span>[];
<span class="ident">buf</span>.<span class="ident">put_i16</span>(<span class="number">0x0809</span>);
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">buf</span>, <span class="string">b&quot;\x08\x09&quot;</span>);</pre></div>
<h1 id="panics-6" class="section-header"><a href="#panics-6">Panics</a></h1>
<p>This function panics if there is not enough remaining capacity in
<code>self</code>.</p>
</div><h3 id="method.put_i16_le" class="method"><code>fn <a href="#method.put_i16_le" class="fnname">put_i16_le</a>(&amp;mut self, n: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.i16.html">i16</a>)</code><a class="srclink" href="../../src/bytes/buf/buf_mut.rs.html#384-386" title="goto source code">[src]</a></h3><div class="docblock"><p>Writes a signed 16 bit integer to <code>self</code> in little-endian byte order.</p>
<p>The current position is advanced by 2.</p>
<h1 id="examples-10" class="section-header"><a href="#examples-10">Examples</a></h1>
<div class="example-wrap"><pre class="rust rust-example-rendered">
<span class="kw">use</span> <span class="ident">bytes</span>::<span class="ident">BufMut</span>;
<span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">buf</span> <span class="op">=</span> <span class="macro">vec</span><span class="macro">!</span>[];
<span class="ident">buf</span>.<span class="ident">put_i16_le</span>(<span class="number">0x0809</span>);
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">buf</span>, <span class="string">b&quot;\x09\x08&quot;</span>);</pre></div>
<h1 id="panics-7" class="section-header"><a href="#panics-7">Panics</a></h1>
<p>This function panics if there is not enough remaining capacity in
<code>self</code>.</p>
</div><h3 id="method.put_u32" class="method"><code>fn <a href="#method.put_u32" class="fnname">put_u32</a>(&amp;mut self, n: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.u32.html">u32</a>)</code><a class="srclink" href="../../src/bytes/buf/buf_mut.rs.html#406-408" title="goto source code">[src]</a></h3><div class="docblock"><p>Writes an unsigned 32 bit integer to <code>self</code> in big-endian byte order.</p>
<p>The current position is advanced by 4.</p>
<h1 id="examples-11" class="section-header"><a href="#examples-11">Examples</a></h1>
<div class="example-wrap"><pre class="rust rust-example-rendered">
<span class="kw">use</span> <span class="ident">bytes</span>::<span class="ident">BufMut</span>;
<span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">buf</span> <span class="op">=</span> <span class="macro">vec</span><span class="macro">!</span>[];
<span class="ident">buf</span>.<span class="ident">put_u32</span>(<span class="number">0x0809A0A1</span>);
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">buf</span>, <span class="string">b&quot;\x08\x09\xA0\xA1&quot;</span>);</pre></div>
<h1 id="panics-8" class="section-header"><a href="#panics-8">Panics</a></h1>
<p>This function panics if there is not enough remaining capacity in
<code>self</code>.</p>
</div><h3 id="method.put_u32_le" class="method"><code>fn <a href="#method.put_u32_le" class="fnname">put_u32_le</a>(&amp;mut self, n: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.u32.html">u32</a>)</code><a class="srclink" href="../../src/bytes/buf/buf_mut.rs.html#428-430" title="goto source code">[src]</a></h3><div class="docblock"><p>Writes an unsigned 32 bit integer to <code>self</code> in little-endian byte order.</p>
<p>The current position is advanced by 4.</p>
<h1 id="examples-12" class="section-header"><a href="#examples-12">Examples</a></h1>
<div class="example-wrap"><pre class="rust rust-example-rendered">
<span class="kw">use</span> <span class="ident">bytes</span>::<span class="ident">BufMut</span>;
<span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">buf</span> <span class="op">=</span> <span class="macro">vec</span><span class="macro">!</span>[];
<span class="ident">buf</span>.<span class="ident">put_u32_le</span>(<span class="number">0x0809A0A1</span>);
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">buf</span>, <span class="string">b&quot;\xA1\xA0\x09\x08&quot;</span>);</pre></div>
<h1 id="panics-9" class="section-header"><a href="#panics-9">Panics</a></h1>
<p>This function panics if there is not enough remaining capacity in
<code>self</code>.</p>
</div><h3 id="method.put_i32" class="method"><code>fn <a href="#method.put_i32" class="fnname">put_i32</a>(&amp;mut self, n: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.i32.html">i32</a>)</code><a class="srclink" href="../../src/bytes/buf/buf_mut.rs.html#450-452" title="goto source code">[src]</a></h3><div class="docblock"><p>Writes a signed 32 bit integer to <code>self</code> in big-endian byte order.</p>
<p>The current position is advanced by 4.</p>
<h1 id="examples-13" class="section-header"><a href="#examples-13">Examples</a></h1>
<div class="example-wrap"><pre class="rust rust-example-rendered">
<span class="kw">use</span> <span class="ident">bytes</span>::<span class="ident">BufMut</span>;
<span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">buf</span> <span class="op">=</span> <span class="macro">vec</span><span class="macro">!</span>[];
<span class="ident">buf</span>.<span class="ident">put_i32</span>(<span class="number">0x0809A0A1</span>);
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">buf</span>, <span class="string">b&quot;\x08\x09\xA0\xA1&quot;</span>);</pre></div>
<h1 id="panics-10" class="section-header"><a href="#panics-10">Panics</a></h1>
<p>This function panics if there is not enough remaining capacity in
<code>self</code>.</p>
</div><h3 id="method.put_i32_le" class="method"><code>fn <a href="#method.put_i32_le" class="fnname">put_i32_le</a>(&amp;mut self, n: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.i32.html">i32</a>)</code><a class="srclink" href="../../src/bytes/buf/buf_mut.rs.html#472-474" title="goto source code">[src]</a></h3><div class="docblock"><p>Writes a signed 32 bit integer to <code>self</code> in little-endian byte order.</p>
<p>The current position is advanced by 4.</p>
<h1 id="examples-14" class="section-header"><a href="#examples-14">Examples</a></h1>
<div class="example-wrap"><pre class="rust rust-example-rendered">
<span class="kw">use</span> <span class="ident">bytes</span>::<span class="ident">BufMut</span>;
<span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">buf</span> <span class="op">=</span> <span class="macro">vec</span><span class="macro">!</span>[];
<span class="ident">buf</span>.<span class="ident">put_i32_le</span>(<span class="number">0x0809A0A1</span>);
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">buf</span>, <span class="string">b&quot;\xA1\xA0\x09\x08&quot;</span>);</pre></div>
<h1 id="panics-11" class="section-header"><a href="#panics-11">Panics</a></h1>
<p>This function panics if there is not enough remaining capacity in
<code>self</code>.</p>
</div><h3 id="method.put_u64" class="method"><code>fn <a href="#method.put_u64" class="fnname">put_u64</a>(&amp;mut self, n: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.u64.html">u64</a>)</code><a class="srclink" href="../../src/bytes/buf/buf_mut.rs.html#494-496" title="goto source code">[src]</a></h3><div class="docblock"><p>Writes an unsigned 64 bit integer to <code>self</code> in the big-endian byte order.</p>
<p>The current position is advanced by 8.</p>
<h1 id="examples-15" class="section-header"><a href="#examples-15">Examples</a></h1>
<div class="example-wrap"><pre class="rust rust-example-rendered">
<span class="kw">use</span> <span class="ident">bytes</span>::<span class="ident">BufMut</span>;
<span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">buf</span> <span class="op">=</span> <span class="macro">vec</span><span class="macro">!</span>[];
<span class="ident">buf</span>.<span class="ident">put_u64</span>(<span class="number">0x0102030405060708</span>);
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">buf</span>, <span class="string">b&quot;\x01\x02\x03\x04\x05\x06\x07\x08&quot;</span>);</pre></div>
<h1 id="panics-12" class="section-header"><a href="#panics-12">Panics</a></h1>
<p>This function panics if there is not enough remaining capacity in
<code>self</code>.</p>
</div><h3 id="method.put_u64_le" class="method"><code>fn <a href="#method.put_u64_le" class="fnname">put_u64_le</a>(&amp;mut self, n: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.u64.html">u64</a>)</code><a class="srclink" href="../../src/bytes/buf/buf_mut.rs.html#516-518" title="goto source code">[src]</a></h3><div class="docblock"><p>Writes an unsigned 64 bit integer to <code>self</code> in little-endian byte order.</p>
<p>The current position is advanced by 8.</p>
<h1 id="examples-16" class="section-header"><a href="#examples-16">Examples</a></h1>
<div class="example-wrap"><pre class="rust rust-example-rendered">
<span class="kw">use</span> <span class="ident">bytes</span>::<span class="ident">BufMut</span>;
<span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">buf</span> <span class="op">=</span> <span class="macro">vec</span><span class="macro">!</span>[];
<span class="ident">buf</span>.<span class="ident">put_u64_le</span>(<span class="number">0x0102030405060708</span>);
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">buf</span>, <span class="string">b&quot;\x08\x07\x06\x05\x04\x03\x02\x01&quot;</span>);</pre></div>
<h1 id="panics-13" class="section-header"><a href="#panics-13">Panics</a></h1>
<p>This function panics if there is not enough remaining capacity in
<code>self</code>.</p>
</div><h3 id="method.put_i64" class="method"><code>fn <a href="#method.put_i64" class="fnname">put_i64</a>(&amp;mut self, n: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.i64.html">i64</a>)</code><a class="srclink" href="../../src/bytes/buf/buf_mut.rs.html#538-540" title="goto source code">[src]</a></h3><div class="docblock"><p>Writes a signed 64 bit integer to <code>self</code> in the big-endian byte order.</p>
<p>The current position is advanced by 8.</p>
<h1 id="examples-17" class="section-header"><a href="#examples-17">Examples</a></h1>
<div class="example-wrap"><pre class="rust rust-example-rendered">
<span class="kw">use</span> <span class="ident">bytes</span>::<span class="ident">BufMut</span>;
<span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">buf</span> <span class="op">=</span> <span class="macro">vec</span><span class="macro">!</span>[];
<span class="ident">buf</span>.<span class="ident">put_i64</span>(<span class="number">0x0102030405060708</span>);
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">buf</span>, <span class="string">b&quot;\x01\x02\x03\x04\x05\x06\x07\x08&quot;</span>);</pre></div>
<h1 id="panics-14" class="section-header"><a href="#panics-14">Panics</a></h1>
<p>This function panics if there is not enough remaining capacity in
<code>self</code>.</p>
</div><h3 id="method.put_i64_le" class="method"><code>fn <a href="#method.put_i64_le" class="fnname">put_i64_le</a>(&amp;mut self, n: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.i64.html">i64</a>)</code><a class="srclink" href="../../src/bytes/buf/buf_mut.rs.html#560-562" title="goto source code">[src]</a></h3><div class="docblock"><p>Writes a signed 64 bit integer to <code>self</code> in little-endian byte order.</p>
<p>The current position is advanced by 8.</p>
<h1 id="examples-18" class="section-header"><a href="#examples-18">Examples</a></h1>
<div class="example-wrap"><pre class="rust rust-example-rendered">
<span class="kw">use</span> <span class="ident">bytes</span>::<span class="ident">BufMut</span>;
<span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">buf</span> <span class="op">=</span> <span class="macro">vec</span><span class="macro">!</span>[];
<span class="ident">buf</span>.<span class="ident">put_i64_le</span>(<span class="number">0x0102030405060708</span>);
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">buf</span>, <span class="string">b&quot;\x08\x07\x06\x05\x04\x03\x02\x01&quot;</span>);</pre></div>
<h1 id="panics-15" class="section-header"><a href="#panics-15">Panics</a></h1>
<p>This function panics if there is not enough remaining capacity in
<code>self</code>.</p>
</div><h3 id="method.put_u128" class="method"><code>fn <a href="#method.put_u128" class="fnname">put_u128</a>(&amp;mut self, n: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.u128.html">u128</a>)</code><a class="srclink" href="../../src/bytes/buf/buf_mut.rs.html#582-584" title="goto source code">[src]</a></h3><div class="docblock"><p>Writes an unsigned 128 bit integer to <code>self</code> in the big-endian byte order.</p>
<p>The current position is advanced by 16.</p>
<h1 id="examples-19" class="section-header"><a href="#examples-19">Examples</a></h1>
<div class="example-wrap"><pre class="rust rust-example-rendered">
<span class="kw">use</span> <span class="ident">bytes</span>::<span class="ident">BufMut</span>;
<span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">buf</span> <span class="op">=</span> <span class="macro">vec</span><span class="macro">!</span>[];
<span class="ident">buf</span>.<span class="ident">put_u128</span>(<span class="number">0x01020304050607080910111213141516</span>);
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">buf</span>, <span class="string">b&quot;\x01\x02\x03\x04\x05\x06\x07\x08\x09\x10\x11\x12\x13\x14\x15\x16&quot;</span>);</pre></div>
<h1 id="panics-16" class="section-header"><a href="#panics-16">Panics</a></h1>
<p>This function panics if there is not enough remaining capacity in
<code>self</code>.</p>
</div><h3 id="method.put_u128_le" class="method"><code>fn <a href="#method.put_u128_le" class="fnname">put_u128_le</a>(&amp;mut self, n: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.u128.html">u128</a>)</code><a class="srclink" href="../../src/bytes/buf/buf_mut.rs.html#604-606" title="goto source code">[src]</a></h3><div class="docblock"><p>Writes an unsigned 128 bit integer to <code>self</code> in little-endian byte order.</p>
<p>The current position is advanced by 16.</p>
<h1 id="examples-20" class="section-header"><a href="#examples-20">Examples</a></h1>
<div class="example-wrap"><pre class="rust rust-example-rendered">
<span class="kw">use</span> <span class="ident">bytes</span>::<span class="ident">BufMut</span>;
<span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">buf</span> <span class="op">=</span> <span class="macro">vec</span><span class="macro">!</span>[];
<span class="ident">buf</span>.<span class="ident">put_u128_le</span>(<span class="number">0x01020304050607080910111213141516</span>);
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">buf</span>, <span class="string">b&quot;\x16\x15\x14\x13\x12\x11\x10\x09\x08\x07\x06\x05\x04\x03\x02\x01&quot;</span>);</pre></div>
<h1 id="panics-17" class="section-header"><a href="#panics-17">Panics</a></h1>
<p>This function panics if there is not enough remaining capacity in
<code>self</code>.</p>
</div><h3 id="method.put_i128" class="method"><code>fn <a href="#method.put_i128" class="fnname">put_i128</a>(&amp;mut self, n: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.i128.html">i128</a>)</code><a class="srclink" href="../../src/bytes/buf/buf_mut.rs.html#626-628" title="goto source code">[src]</a></h3><div class="docblock"><p>Writes a signed 128 bit integer to <code>self</code> in the big-endian byte order.</p>
<p>The current position is advanced by 16.</p>
<h1 id="examples-21" class="section-header"><a href="#examples-21">Examples</a></h1>
<div class="example-wrap"><pre class="rust rust-example-rendered">
<span class="kw">use</span> <span class="ident">bytes</span>::<span class="ident">BufMut</span>;
<span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">buf</span> <span class="op">=</span> <span class="macro">vec</span><span class="macro">!</span>[];
<span class="ident">buf</span>.<span class="ident">put_i128</span>(<span class="number">0x01020304050607080910111213141516</span>);
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">buf</span>, <span class="string">b&quot;\x01\x02\x03\x04\x05\x06\x07\x08\x09\x10\x11\x12\x13\x14\x15\x16&quot;</span>);</pre></div>
<h1 id="panics-18" class="section-header"><a href="#panics-18">Panics</a></h1>
<p>This function panics if there is not enough remaining capacity in
<code>self</code>.</p>
</div><h3 id="method.put_i128_le" class="method"><code>fn <a href="#method.put_i128_le" class="fnname">put_i128_le</a>(&amp;mut self, n: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.i128.html">i128</a>)</code><a class="srclink" href="../../src/bytes/buf/buf_mut.rs.html#648-650" title="goto source code">[src]</a></h3><div class="docblock"><p>Writes a signed 128 bit integer to <code>self</code> in little-endian byte order.</p>
<p>The current position is advanced by 16.</p>
<h1 id="examples-22" class="section-header"><a href="#examples-22">Examples</a></h1>
<div class="example-wrap"><pre class="rust rust-example-rendered">
<span class="kw">use</span> <span class="ident">bytes</span>::<span class="ident">BufMut</span>;
<span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">buf</span> <span class="op">=</span> <span class="macro">vec</span><span class="macro">!</span>[];
<span class="ident">buf</span>.<span class="ident">put_i128_le</span>(<span class="number">0x01020304050607080910111213141516</span>);
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">buf</span>, <span class="string">b&quot;\x16\x15\x14\x13\x12\x11\x10\x09\x08\x07\x06\x05\x04\x03\x02\x01&quot;</span>);</pre></div>
<h1 id="panics-19" class="section-header"><a href="#panics-19">Panics</a></h1>
<p>This function panics if there is not enough remaining capacity in
<code>self</code>.</p>
</div><h3 id="method.put_uint" class="method"><code>fn <a href="#method.put_uint" class="fnname">put_uint</a>(&amp;mut self, n: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.u64.html">u64</a>, nbytes: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.usize.html">usize</a>)</code><a class="srclink" href="../../src/bytes/buf/buf_mut.rs.html#670-672" title="goto source code">[src]</a></h3><div class="docblock"><p>Writes an unsigned n-byte integer to <code>self</code> in big-endian byte order.</p>
<p>The current position is advanced by <code>nbytes</code>.</p>
<h1 id="examples-23" class="section-header"><a href="#examples-23">Examples</a></h1>
<div class="example-wrap"><pre class="rust rust-example-rendered">
<span class="kw">use</span> <span class="ident">bytes</span>::<span class="ident">BufMut</span>;
<span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">buf</span> <span class="op">=</span> <span class="macro">vec</span><span class="macro">!</span>[];
<span class="ident">buf</span>.<span class="ident">put_uint</span>(<span class="number">0x010203</span>, <span class="number">3</span>);
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">buf</span>, <span class="string">b&quot;\x01\x02\x03&quot;</span>);</pre></div>
<h1 id="panics-20" class="section-header"><a href="#panics-20">Panics</a></h1>
<p>This function panics if there is not enough remaining capacity in
<code>self</code>.</p>
</div><h3 id="method.put_uint_le" class="method"><code>fn <a href="#method.put_uint_le" class="fnname">put_uint_le</a>(&amp;mut self, n: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.u64.html">u64</a>, nbytes: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.usize.html">usize</a>)</code><a class="srclink" href="../../src/bytes/buf/buf_mut.rs.html#692-694" title="goto source code">[src]</a></h3><div class="docblock"><p>Writes an unsigned n-byte integer to <code>self</code> in the little-endian byte order.</p>
<p>The current position is advanced by <code>nbytes</code>.</p>
<h1 id="examples-24" class="section-header"><a href="#examples-24">Examples</a></h1>
<div class="example-wrap"><pre class="rust rust-example-rendered">
<span class="kw">use</span> <span class="ident">bytes</span>::<span class="ident">BufMut</span>;
<span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">buf</span> <span class="op">=</span> <span class="macro">vec</span><span class="macro">!</span>[];
<span class="ident">buf</span>.<span class="ident">put_uint_le</span>(<span class="number">0x010203</span>, <span class="number">3</span>);
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">buf</span>, <span class="string">b&quot;\x03\x02\x01&quot;</span>);</pre></div>
<h1 id="panics-21" class="section-header"><a href="#panics-21">Panics</a></h1>
<p>This function panics if there is not enough remaining capacity in
<code>self</code>.</p>
</div><h3 id="method.put_int" class="method"><code>fn <a href="#method.put_int" class="fnname">put_int</a>(&amp;mut self, n: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.i64.html">i64</a>, nbytes: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.usize.html">usize</a>)</code><a class="srclink" href="../../src/bytes/buf/buf_mut.rs.html#714-716" title="goto source code">[src]</a></h3><div class="docblock"><p>Writes a signed n-byte integer to <code>self</code> in big-endian byte order.</p>
<p>The current position is advanced by <code>nbytes</code>.</p>
<h1 id="examples-25" class="section-header"><a href="#examples-25">Examples</a></h1>
<div class="example-wrap"><pre class="rust rust-example-rendered">
<span class="kw">use</span> <span class="ident">bytes</span>::<span class="ident">BufMut</span>;
<span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">buf</span> <span class="op">=</span> <span class="macro">vec</span><span class="macro">!</span>[];
<span class="ident">buf</span>.<span class="ident">put_int</span>(<span class="number">0x010203</span>, <span class="number">3</span>);
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">buf</span>, <span class="string">b&quot;\x01\x02\x03&quot;</span>);</pre></div>
<h1 id="panics-22" class="section-header"><a href="#panics-22">Panics</a></h1>
<p>This function panics if there is not enough remaining capacity in
<code>self</code>.</p>
</div><h3 id="method.put_int_le" class="method"><code>fn <a href="#method.put_int_le" class="fnname">put_int_le</a>(&amp;mut self, n: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.i64.html">i64</a>, nbytes: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.usize.html">usize</a>)</code><a class="srclink" href="../../src/bytes/buf/buf_mut.rs.html#736-738" title="goto source code">[src]</a></h3><div class="docblock"><p>Writes a signed n-byte integer to <code>self</code> in little-endian byte order.</p>
<p>The current position is advanced by <code>nbytes</code>.</p>
<h1 id="examples-26" class="section-header"><a href="#examples-26">Examples</a></h1>
<div class="example-wrap"><pre class="rust rust-example-rendered">
<span class="kw">use</span> <span class="ident">bytes</span>::<span class="ident">BufMut</span>;
<span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">buf</span> <span class="op">=</span> <span class="macro">vec</span><span class="macro">!</span>[];
<span class="ident">buf</span>.<span class="ident">put_int_le</span>(<span class="number">0x010203</span>, <span class="number">3</span>);
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">buf</span>, <span class="string">b&quot;\x03\x02\x01&quot;</span>);</pre></div>
<h1 id="panics-23" class="section-header"><a href="#panics-23">Panics</a></h1>
<p>This function panics if there is not enough remaining capacity in
<code>self</code>.</p>
</div><h3 id="method.put_f32" class="method"><code>fn <a href="#method.put_f32" class="fnname">put_f32</a>(&amp;mut self, n: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.f32.html">f32</a>)</code><a class="srclink" href="../../src/bytes/buf/buf_mut.rs.html#759-761" title="goto source code">[src]</a></h3><div class="docblock"><p>Writes an IEEE754 single-precision (4 bytes) floating point number to
<code>self</code> in big-endian byte order.</p>
<p>The current position is advanced by 4.</p>
<h1 id="examples-27" class="section-header"><a href="#examples-27">Examples</a></h1>
<div class="example-wrap"><pre class="rust rust-example-rendered">
<span class="kw">use</span> <span class="ident">bytes</span>::<span class="ident">BufMut</span>;
<span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">buf</span> <span class="op">=</span> <span class="macro">vec</span><span class="macro">!</span>[];
<span class="ident">buf</span>.<span class="ident">put_f32</span>(<span class="number">1.2f32</span>);
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">buf</span>, <span class="string">b&quot;\x3F\x99\x99\x9A&quot;</span>);</pre></div>
<h1 id="panics-24" class="section-header"><a href="#panics-24">Panics</a></h1>
<p>This function panics if there is not enough remaining capacity in
<code>self</code>.</p>
</div><h3 id="method.put_f32_le" class="method"><code>fn <a href="#method.put_f32_le" class="fnname">put_f32_le</a>(&amp;mut self, n: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.f32.html">f32</a>)</code><a class="srclink" href="../../src/bytes/buf/buf_mut.rs.html#782-784" title="goto source code">[src]</a></h3><div class="docblock"><p>Writes an IEEE754 single-precision (4 bytes) floating point number to
<code>self</code> in little-endian byte order.</p>
<p>The current position is advanced by 4.</p>
<h1 id="examples-28" class="section-header"><a href="#examples-28">Examples</a></h1>
<div class="example-wrap"><pre class="rust rust-example-rendered">
<span class="kw">use</span> <span class="ident">bytes</span>::<span class="ident">BufMut</span>;
<span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">buf</span> <span class="op">=</span> <span class="macro">vec</span><span class="macro">!</span>[];
<span class="ident">buf</span>.<span class="ident">put_f32_le</span>(<span class="number">1.2f32</span>);
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">buf</span>, <span class="string">b&quot;\x9A\x99\x99\x3F&quot;</span>);</pre></div>
<h1 id="panics-25" class="section-header"><a href="#panics-25">Panics</a></h1>
<p>This function panics if there is not enough remaining capacity in
<code>self</code>.</p>
</div><h3 id="method.put_f64" class="method"><code>fn <a href="#method.put_f64" class="fnname">put_f64</a>(&amp;mut self, n: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.f64.html">f64</a>)</code><a class="srclink" href="../../src/bytes/buf/buf_mut.rs.html#805-807" title="goto source code">[src]</a></h3><div class="docblock"><p>Writes an IEEE754 double-precision (8 bytes) floating point number to
<code>self</code> in big-endian byte order.</p>
<p>The current position is advanced by 8.</p>
<h1 id="examples-29" class="section-header"><a href="#examples-29">Examples</a></h1>
<div class="example-wrap"><pre class="rust rust-example-rendered">
<span class="kw">use</span> <span class="ident">bytes</span>::<span class="ident">BufMut</span>;
<span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">buf</span> <span class="op">=</span> <span class="macro">vec</span><span class="macro">!</span>[];
<span class="ident">buf</span>.<span class="ident">put_f64</span>(<span class="number">1.2f64</span>);
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">buf</span>, <span class="string">b&quot;\x3F\xF3\x33\x33\x33\x33\x33\x33&quot;</span>);</pre></div>
<h1 id="panics-26" class="section-header"><a href="#panics-26">Panics</a></h1>
<p>This function panics if there is not enough remaining capacity in
<code>self</code>.</p>
</div><h3 id="method.put_f64_le" class="method"><code>fn <a href="#method.put_f64_le" class="fnname">put_f64_le</a>(&amp;mut self, n: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.f64.html">f64</a>)</code><a class="srclink" href="../../src/bytes/buf/buf_mut.rs.html#828-830" title="goto source code">[src]</a></h3><div class="docblock"><p>Writes an IEEE754 double-precision (8 bytes) floating point number to
<code>self</code> in little-endian byte order.</p>
<p>The current position is advanced by 8.</p>
<h1 id="examples-30" class="section-header"><a href="#examples-30">Examples</a></h1>
<div class="example-wrap"><pre class="rust rust-example-rendered">
<span class="kw">use</span> <span class="ident">bytes</span>::<span class="ident">BufMut</span>;
<span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">buf</span> <span class="op">=</span> <span class="macro">vec</span><span class="macro">!</span>[];
<span class="ident">buf</span>.<span class="ident">put_f64_le</span>(<span class="number">1.2f64</span>);
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">buf</span>, <span class="string">b&quot;\x33\x33\x33\x33\x33\x33\xF3\x3F&quot;</span>);</pre></div>
<h1 id="panics-27" class="section-header"><a href="#panics-27">Panics</a></h1>
<p>This function panics if there is not enough remaining capacity in
<code>self</code>.</p>
</div><h3 id="method.limit" class="method"><code>fn <a href="#method.limit" class="fnname">limit</a>(self, limit: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.usize.html">usize</a>) -&gt; <a class="struct" href="../../bytes/buf/struct.Limit.html" title="struct bytes::buf::Limit">Limit</a>&lt;Self&gt; <span class="where fmt-newline">where<br>&nbsp;&nbsp;&nbsp;&nbsp;Self: <a class="trait" href="https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html" title="trait core::marker::Sized">Sized</a>,&nbsp;</span></code><a class="srclink" href="../../src/bytes/buf/buf_mut.rs.html#845-850" title="goto source code">[src]</a></h3><div class="docblock"><p>Creates an adaptor which can write at most <code>limit</code> bytes to <code>self</code>.</p>
<h1 id="examples-31" class="section-header"><a href="#examples-31">Examples</a></h1>
<div class="example-wrap"><pre class="rust rust-example-rendered">
<span class="kw">use</span> <span class="ident">bytes</span>::<span class="ident">BufMut</span>;
<span class="kw">let</span> <span class="ident">arr</span> <span class="op">=</span> <span class="kw-2">&amp;</span><span class="kw-2">mut</span> [<span class="number">0u8</span>; <span class="number">128</span>][..];
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">arr</span>.<span class="ident">remaining_mut</span>(), <span class="number">128</span>);
<span class="kw">let</span> <span class="ident">dst</span> <span class="op">=</span> <span class="ident">arr</span>.<span class="ident">limit</span>(<span class="number">10</span>);
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">dst</span>.<span class="ident">remaining_mut</span>(), <span class="number">10</span>);</pre></div>
</div><h3 id="method.writer" class="method"><code>fn <a href="#method.writer" class="fnname">writer</a>(self) -&gt; <a class="struct" href="../../bytes/buf/struct.Writer.html" title="struct bytes::buf::Writer">Writer</a>&lt;Self&gt;<span class="notable-traits"><span class="notable-traits-tooltip">ⓘ<div class="notable-traits-tooltiptext"><span class="docblock"><h3 class="notable">Notable traits for <a class="struct" href="../../bytes/buf/struct.Writer.html" title="struct bytes::buf::Writer">Writer</a>&lt;B&gt;</h3><code class="content"><span class="where fmt-newline">impl&lt;B:&nbsp;<a class="trait" href="../../bytes/buf/trait.BufMut.html" title="trait bytes::buf::BufMut">BufMut</a> + <a class="trait" href="https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html" title="trait core::marker::Sized">Sized</a>&gt; <a class="trait" href="https://doc.rust-lang.org/nightly/std/io/trait.Write.html" title="trait std::io::Write">Write</a> for <a class="struct" href="../../bytes/buf/struct.Writer.html" title="struct bytes::buf::Writer">Writer</a>&lt;B&gt;</span></code></span></div></span></span> <span class="where fmt-newline">where<br>&nbsp;&nbsp;&nbsp;&nbsp;Self: <a class="trait" href="https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html" title="trait core::marker::Sized">Sized</a>,&nbsp;</span></code><a class="srclink" href="../../src/bytes/buf/buf_mut.rs.html#875-880" title="goto source code">[src]</a></h3><div class="docblock"><p>Creates an adaptor which implements the <code>Write</code> trait for <code>self</code>.</p>
<p>This function returns a new value which implements <code>Write</code> by adapting
the <code>Write</code> trait functions to the <code>BufMut</code> trait functions. Given that
<code>BufMut</code> operations are infallible, none of the <code>Write</code> functions will
return with <code>Err</code>.</p>
<h1 id="examples-32" class="section-header"><a href="#examples-32">Examples</a></h1>
<div class="example-wrap"><pre class="rust rust-example-rendered">
<span class="kw">use</span> <span class="ident">bytes</span>::<span class="ident">BufMut</span>;
<span class="kw">use</span> <span class="ident">std</span>::<span class="ident">io</span>::<span class="ident">Write</span>;
<span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">buf</span> <span class="op">=</span> <span class="macro">vec</span><span class="macro">!</span>[].<span class="ident">writer</span>();
<span class="kw">let</span> <span class="ident">num</span> <span class="op">=</span> <span class="ident">buf</span>.<span class="ident">write</span>(<span class="kw-2">&amp;</span><span class="string">b&quot;hello world&quot;</span>[..]).<span class="ident">unwrap</span>();
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="number">11</span>, <span class="ident">num</span>);
<span class="kw">let</span> <span class="ident">buf</span> <span class="op">=</span> <span class="ident">buf</span>.<span class="ident">into_inner</span>();
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="kw-2">*</span><span class="ident">buf</span>, <span class="string">b&quot;hello world&quot;</span>[..]);</pre></div>
</div><h3 id="method.chain_mut" class="method"><code>fn <a href="#method.chain_mut" class="fnname">chain_mut</a>&lt;U:&nbsp;<a class="trait" href="../../bytes/buf/trait.BufMut.html" title="trait bytes::buf::BufMut">BufMut</a>&gt;(self, next: U) -&gt; <a class="struct" href="../../bytes/buf/struct.Chain.html" title="struct bytes::buf::Chain">Chain</a>&lt;Self, U&gt; <span class="where fmt-newline">where<br>&nbsp;&nbsp;&nbsp;&nbsp;Self: <a class="trait" href="https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html" title="trait core::marker::Sized">Sized</a>,&nbsp;</span></code><a class="srclink" href="../../src/bytes/buf/buf_mut.rs.html#902-907" title="goto source code">[src]</a></h3><div class="docblock"><p>Creates an adapter which will chain this buffer with another.</p>
<p>The returned <code>BufMut</code> instance will first write to all bytes from
<code>self</code>. Afterwards, it will write to <code>next</code>.</p>
<h1 id="examples-33" class="section-header"><a href="#examples-33">Examples</a></h1>
<div class="example-wrap"><pre class="rust rust-example-rendered">
<span class="kw">use</span> <span class="ident">bytes</span>::<span class="ident">BufMut</span>;
<span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">a</span> <span class="op">=</span> [<span class="number">0u8</span>; <span class="number">5</span>];
<span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">b</span> <span class="op">=</span> [<span class="number">0u8</span>; <span class="number">6</span>];
<span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">chain</span> <span class="op">=</span> (<span class="kw-2">&amp;</span><span class="kw-2">mut</span> <span class="ident">a</span>[..]).<span class="ident">chain_mut</span>(<span class="kw-2">&amp;</span><span class="kw-2">mut</span> <span class="ident">b</span>[..]);
<span class="ident">chain</span>.<span class="ident">put_slice</span>(<span class="string">b&quot;hello world&quot;</span>);
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="kw-2">&amp;</span><span class="ident">a</span>[..], <span class="string">b&quot;hello&quot;</span>);
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="kw-2">&amp;</span><span class="ident">b</span>[..], <span class="string">b&quot; world&quot;</span>);</pre></div>
</div></div><span class="loading-content">Loading content...</span><h2 id="foreign-impls" class="small-section-header">Implementations on Foreign Types<a href="#foreign-impls" class="anchor"></a></h2><h3 id="impl-BufMut-for-%26mut%20T" class="impl"><code class="in-band">impl&lt;T:&nbsp;<a class="trait" href="../../bytes/buf/trait.BufMut.html" title="trait bytes::buf::BufMut">BufMut</a> + ?<a class="trait" href="https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html" title="trait core::marker::Sized">Sized</a>&gt; <a class="trait" href="../../bytes/buf/trait.BufMut.html" title="trait bytes::buf::BufMut">BufMut</a> for <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.reference.html">&amp;mut </a>T</code><a href="#impl-BufMut-for-%26mut%20T" class="anchor"></a><a class="srclink" href="../../src/bytes/buf/buf_mut.rs.html#986-988" title="goto source code">[src]</a></h3><div class="impl-items"><h4 id="method.remaining_mut" class="method hidden"><code>fn <a href="#method.remaining_mut" class="fnname">remaining_mut</a>(&amp;self) -&gt; <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.usize.html">usize</a></code><a class="srclink" href="../../src/bytes/buf/buf_mut.rs.html#987" title="goto source code">[src]</a></h4><h4 id="method.chunk_mut" class="method hidden"><code>fn <a href="#method.chunk_mut" class="fnname">chunk_mut</a>(&amp;mut self) -&gt; &amp;mut <a class="struct" href="../../bytes/buf/struct.UninitSlice.html" title="struct bytes::buf::UninitSlice">UninitSlice</a></code><a class="srclink" href="../../src/bytes/buf/buf_mut.rs.html#987" title="goto source code">[src]</a></h4><h4 id="method.advance_mut" class="method hidden"><code>unsafe fn <a href="#method.advance_mut" class="fnname">advance_mut</a>(&amp;mut self, cnt: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.usize.html">usize</a>)</code><a class="srclink" href="../../src/bytes/buf/buf_mut.rs.html#987" title="goto source code">[src]</a></h4><h4 id="method.put_slice-1" class="method hidden"><code>fn <a href="#method.put_slice" class="fnname">put_slice</a>(&amp;mut self, src: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.slice.html">&amp;[</a><a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.u8.html">u8</a><a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.slice.html">]</a>)</code><a class="srclink" href="../../src/bytes/buf/buf_mut.rs.html#987" title="goto source code">[src]</a></h4><h4 id="method.put_u8-1" class="method hidden"><code>fn <a href="#method.put_u8" class="fnname">put_u8</a>(&amp;mut self, n: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.u8.html">u8</a>)</code><a class="srclink" href="../../src/bytes/buf/buf_mut.rs.html#987" title="goto source code">[src]</a></h4><h4 id="method.put_i8-1" class="method hidden"><code>fn <a href="#method.put_i8" class="fnname">put_i8</a>(&amp;mut self, n: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.i8.html">i8</a>)</code><a class="srclink" href="../../src/bytes/buf/buf_mut.rs.html#987" title="goto source code">[src]</a></h4><h4 id="method.put_u16-1" class="method hidden"><code>fn <a href="#method.put_u16" class="fnname">put_u16</a>(&amp;mut self, n: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.u16.html">u16</a>)</code><a class="srclink" href="../../src/bytes/buf/buf_mut.rs.html#987" title="goto source code">[src]</a></h4><h4 id="method.put_u16_le-1" class="method hidden"><code>fn <a href="#method.put_u16_le" class="fnname">put_u16_le</a>(&amp;mut self, n: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.u16.html">u16</a>)</code><a class="srclink" href="../../src/bytes/buf/buf_mut.rs.html#987" title="goto source code">[src]</a></h4><h4 id="method.put_i16-1" class="method hidden"><code>fn <a href="#method.put_i16" class="fnname">put_i16</a>(&amp;mut self, n: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.i16.html">i16</a>)</code><a class="srclink" href="../../src/bytes/buf/buf_mut.rs.html#987" title="goto source code">[src]</a></h4><h4 id="method.put_i16_le-1" class="method hidden"><code>fn <a href="#method.put_i16_le" class="fnname">put_i16_le</a>(&amp;mut self, n: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.i16.html">i16</a>)</code><a class="srclink" href="../../src/bytes/buf/buf_mut.rs.html#987" title="goto source code">[src]</a></h4><h4 id="method.put_u32-1" class="method hidden"><code>fn <a href="#method.put_u32" class="fnname">put_u32</a>(&amp;mut self, n: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.u32.html">u32</a>)</code><a class="srclink" href="../../src/bytes/buf/buf_mut.rs.html#987" title="goto source code">[src]</a></h4><h4 id="method.put_u32_le-1" class="method hidden"><code>fn <a href="#method.put_u32_le" class="fnname">put_u32_le</a>(&amp;mut self, n: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.u32.html">u32</a>)</code><a class="srclink" href="../../src/bytes/buf/buf_mut.rs.html#987" title="goto source code">[src]</a></h4><h4 id="method.put_i32-1" class="method hidden"><code>fn <a href="#method.put_i32" class="fnname">put_i32</a>(&amp;mut self, n: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.i32.html">i32</a>)</code><a class="srclink" href="../../src/bytes/buf/buf_mut.rs.html#987" title="goto source code">[src]</a></h4><h4 id="method.put_i32_le-1" class="method hidden"><code>fn <a href="#method.put_i32_le" class="fnname">put_i32_le</a>(&amp;mut self, n: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.i32.html">i32</a>)</code><a class="srclink" href="../../src/bytes/buf/buf_mut.rs.html#987" title="goto source code">[src]</a></h4><h4 id="method.put_u64-1" class="method hidden"><code>fn <a href="#method.put_u64" class="fnname">put_u64</a>(&amp;mut self, n: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.u64.html">u64</a>)</code><a class="srclink" href="../../src/bytes/buf/buf_mut.rs.html#987" title="goto source code">[src]</a></h4><h4 id="method.put_u64_le-1" class="method hidden"><code>fn <a href="#method.put_u64_le" class="fnname">put_u64_le</a>(&amp;mut self, n: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.u64.html">u64</a>)</code><a class="srclink" href="../../src/bytes/buf/buf_mut.rs.html#987" title="goto source code">[src]</a></h4><h4 id="method.put_i64-1" class="method hidden"><code>fn <a href="#method.put_i64" class="fnname">put_i64</a>(&amp;mut self, n: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.i64.html">i64</a>)</code><a class="srclink" href="../../src/bytes/buf/buf_mut.rs.html#987" title="goto source code">[src]</a></h4><h4 id="method.put_i64_le-1" class="method hidden"><code>fn <a href="#method.put_i64_le" class="fnname">put_i64_le</a>(&amp;mut self, n: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.i64.html">i64</a>)</code><a class="srclink" href="../../src/bytes/buf/buf_mut.rs.html#987" title="goto source code">[src]</a></h4></div><h3 id="impl-BufMut-for-Box%3CT%3E" class="impl"><code class="in-band">impl&lt;T:&nbsp;<a class="trait" href="../../bytes/buf/trait.BufMut.html" title="trait bytes::buf::BufMut">BufMut</a> + ?<a class="trait" href="https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html" title="trait core::marker::Sized">Sized</a>&gt; <a class="trait" href="../../bytes/buf/trait.BufMut.html" title="trait bytes::buf::BufMut">BufMut</a> for <a class="struct" href="https://doc.rust-lang.org/nightly/alloc/boxed/struct.Box.html" title="struct alloc::boxed::Box">Box</a>&lt;T&gt;</code><a href="#impl-BufMut-for-Box%3CT%3E" class="anchor"></a><a class="srclink" href="../../src/bytes/buf/buf_mut.rs.html#990-992" title="goto source code">[src]</a></h3><div class="impl-items"><h4 id="method.remaining_mut-1" class="method hidden"><code>fn <a href="#method.remaining_mut" class="fnname">remaining_mut</a>(&amp;self) -&gt; <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.usize.html">usize</a></code><a class="srclink" href="../../src/bytes/buf/buf_mut.rs.html#991" title="goto source code">[src]</a></h4><h4 id="method.chunk_mut-1" class="method hidden"><code>fn <a href="#method.chunk_mut" class="fnname">chunk_mut</a>(&amp;mut self) -&gt; &amp;mut <a class="struct" href="../../bytes/buf/struct.UninitSlice.html" title="struct bytes::buf::UninitSlice">UninitSlice</a></code><a class="srclink" href="../../src/bytes/buf/buf_mut.rs.html#991" title="goto source code">[src]</a></h4><h4 id="method.advance_mut-1" class="method hidden"><code>unsafe fn <a href="#method.advance_mut" class="fnname">advance_mut</a>(&amp;mut self, cnt: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.usize.html">usize</a>)</code><a class="srclink" href="../../src/bytes/buf/buf_mut.rs.html#991" title="goto source code">[src]</a></h4><h4 id="method.put_slice-2" class="method hidden"><code>fn <a href="#method.put_slice" class="fnname">put_slice</a>(&amp;mut self, src: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.slice.html">&amp;[</a><a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.u8.html">u8</a><a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.slice.html">]</a>)</code><a class="srclink" href="../../src/bytes/buf/buf_mut.rs.html#991" title="goto source code">[src]</a></h4><h4 id="method.put_u8-2" class="method hidden"><code>fn <a href="#method.put_u8" class="fnname">put_u8</a>(&amp;mut self, n: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.u8.html">u8</a>)</code><a class="srclink" href="../../src/bytes/buf/buf_mut.rs.html#991" title="goto source code">[src]</a></h4><h4 id="method.put_i8-2" class="method hidden"><code>fn <a href="#method.put_i8" class="fnname">put_i8</a>(&amp;mut self, n: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.i8.html">i8</a>)</code><a class="srclink" href="../../src/bytes/buf/buf_mut.rs.html#991" title="goto source code">[src]</a></h4><h4 id="method.put_u16-2" class="method hidden"><code>fn <a href="#method.put_u16" class="fnname">put_u16</a>(&amp;mut self, n: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.u16.html">u16</a>)</code><a class="srclink" href="../../src/bytes/buf/buf_mut.rs.html#991" title="goto source code">[src]</a></h4><h4 id="method.put_u16_le-2" class="method hidden"><code>fn <a href="#method.put_u16_le" class="fnname">put_u16_le</a>(&amp;mut self, n: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.u16.html">u16</a>)</code><a class="srclink" href="../../src/bytes/buf/buf_mut.rs.html#991" title="goto source code">[src]</a></h4><h4 id="method.put_i16-2" class="method hidden"><code>fn <a href="#method.put_i16" class="fnname">put_i16</a>(&amp;mut self, n: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.i16.html">i16</a>)</code><a class="srclink" href="../../src/bytes/buf/buf_mut.rs.html#991" title="goto source code">[src]</a></h4><h4 id="method.put_i16_le-2" class="method hidden"><code>fn <a href="#method.put_i16_le" class="fnname">put_i16_le</a>(&amp;mut self, n: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.i16.html">i16</a>)</code><a class="srclink" href="../../src/bytes/buf/buf_mut.rs.html#991" title="goto source code">[src]</a></h4><h4 id="method.put_u32-2" class="method hidden"><code>fn <a href="#method.put_u32" class="fnname">put_u32</a>(&amp;mut self, n: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.u32.html">u32</a>)</code><a class="srclink" href="../../src/bytes/buf/buf_mut.rs.html#991" title="goto source code">[src]</a></h4><h4 id="method.put_u32_le-2" class="method hidden"><code>fn <a href="#method.put_u32_le" class="fnname">put_u32_le</a>(&amp;mut self, n: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.u32.html">u32</a>)</code><a class="srclink" href="../../src/bytes/buf/buf_mut.rs.html#991" title="goto source code">[src]</a></h4><h4 id="method.put_i32-2" class="method hidden"><code>fn <a href="#method.put_i32" class="fnname">put_i32</a>(&amp;mut self, n: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.i32.html">i32</a>)</code><a class="srclink" href="../../src/bytes/buf/buf_mut.rs.html#991" title="goto source code">[src]</a></h4><h4 id="method.put_i32_le-2" class="method hidden"><code>fn <a href="#method.put_i32_le" class="fnname">put_i32_le</a>(&amp;mut self, n: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.i32.html">i32</a>)</code><a class="srclink" href="../../src/bytes/buf/buf_mut.rs.html#991" title="goto source code">[src]</a></h4><h4 id="method.put_u64-2" class="method hidden"><code>fn <a href="#method.put_u64" class="fnname">put_u64</a>(&amp;mut self, n: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.u64.html">u64</a>)</code><a class="srclink" href="../../src/bytes/buf/buf_mut.rs.html#991" title="goto source code">[src]</a></h4><h4 id="method.put_u64_le-2" class="method hidden"><code>fn <a href="#method.put_u64_le" class="fnname">put_u64_le</a>(&amp;mut self, n: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.u64.html">u64</a>)</code><a class="srclink" href="../../src/bytes/buf/buf_mut.rs.html#991" title="goto source code">[src]</a></h4><h4 id="method.put_i64-2" class="method hidden"><code>fn <a href="#method.put_i64" class="fnname">put_i64</a>(&amp;mut self, n: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.i64.html">i64</a>)</code><a class="srclink" href="../../src/bytes/buf/buf_mut.rs.html#991" title="goto source code">[src]</a></h4><h4 id="method.put_i64_le-2" class="method hidden"><code>fn <a href="#method.put_i64_le" class="fnname">put_i64_le</a>(&amp;mut self, n: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.i64.html">i64</a>)</code><a class="srclink" href="../../src/bytes/buf/buf_mut.rs.html#991" title="goto source code">[src]</a></h4></div><h3 id="impl-BufMut-for-%26mut%20%5Bu8%5D" class="impl"><code class="in-band">impl <a class="trait" href="../../bytes/buf/trait.BufMut.html" title="trait bytes::buf::BufMut">BufMut</a> for <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.slice.html">&amp;mut [</a><a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.u8.html">u8</a><a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.slice.html">]</a></code><a href="#impl-BufMut-for-%26mut%20%5Bu8%5D" class="anchor"></a><a class="srclink" href="../../src/bytes/buf/buf_mut.rs.html#994-1012" title="goto source code">[src]</a></h3><div class="impl-items"><h4 id="method.remaining_mut-2" class="method hidden"><code>fn <a href="#method.remaining_mut" class="fnname">remaining_mut</a>(&amp;self) -&gt; <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.usize.html">usize</a></code><a class="srclink" href="../../src/bytes/buf/buf_mut.rs.html#996-998" title="goto source code">[src]</a></h4><h4 id="method.chunk_mut-2" class="method hidden"><code>fn <a href="#method.chunk_mut" class="fnname">chunk_mut</a>(&amp;mut self) -&gt; &amp;mut <a class="struct" href="../../bytes/buf/struct.UninitSlice.html" title="struct bytes::buf::UninitSlice">UninitSlice</a></code><a class="srclink" href="../../src/bytes/buf/buf_mut.rs.html#1001-1004" title="goto source code">[src]</a></h4><h4 id="method.advance_mut-2" class="method hidden"><code>unsafe fn <a href="#method.advance_mut" class="fnname">advance_mut</a>(&amp;mut self, cnt: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.usize.html">usize</a>)</code><a class="srclink" href="../../src/bytes/buf/buf_mut.rs.html#1007-1011" title="goto source code">[src]</a></h4></div><h3 id="impl-BufMut-for-Vec%3Cu8%3E" class="impl"><code class="in-band">impl <a class="trait" href="../../bytes/buf/trait.BufMut.html" title="trait bytes::buf::BufMut">BufMut</a> for <a class="struct" href="https://doc.rust-lang.org/nightly/alloc/vec/struct.Vec.html" title="struct alloc::vec::Vec">Vec</a>&lt;<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.u8.html">u8</a>&gt;</code><a href="#impl-BufMut-for-Vec%3Cu8%3E" class="anchor"></a><a class="srclink" href="../../src/bytes/buf/buf_mut.rs.html#1014-1075" title="goto source code">[src]</a></h3><div class="impl-items"><h4 id="method.remaining_mut-3" class="method hidden"><code>fn <a href="#method.remaining_mut" class="fnname">remaining_mut</a>(&amp;self) -&gt; <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.usize.html">usize</a></code><a class="srclink" href="../../src/bytes/buf/buf_mut.rs.html#1016-1018" title="goto source code">[src]</a></h4><h4 id="method.advance_mut-3" class="method hidden"><code>unsafe fn <a href="#method.advance_mut" class="fnname">advance_mut</a>(&amp;mut self, cnt: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.usize.html">usize</a>)</code><a class="srclink" href="../../src/bytes/buf/buf_mut.rs.html#1021-1033" title="goto source code">[src]</a></h4><h4 id="method.chunk_mut-3" class="method hidden"><code>fn <a href="#method.chunk_mut" class="fnname">chunk_mut</a>(&amp;mut self) -&gt; &amp;mut <a class="struct" href="../../bytes/buf/struct.UninitSlice.html" title="struct bytes::buf::UninitSlice">UninitSlice</a></code><a class="srclink" href="../../src/bytes/buf/buf_mut.rs.html#1036-1046" title="goto source code">[src]</a></h4><h4 id="method.put-1" class="method hidden"><code>fn <a href="#method.put" class="fnname">put</a>&lt;T:&nbsp;<a class="trait" href="../../bytes/buf/trait.Buf.html" title="trait bytes::buf::Buf">Buf</a>&gt;(&amp;mut self, src: T) <span class="where fmt-newline">where<br>&nbsp;&nbsp;&nbsp;&nbsp;Self: <a class="trait" href="https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html" title="trait core::marker::Sized">Sized</a>,&nbsp;</span></code><a class="srclink" href="../../src/bytes/buf/buf_mut.rs.html#1050-1069" title="goto source code">[src]</a></h4><h4 id="method.put_slice-3" class="method hidden"><code>fn <a href="#method.put_slice" class="fnname">put_slice</a>(&amp;mut self, src: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.slice.html">&amp;[</a><a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.u8.html">u8</a><a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.slice.html">]</a>)</code><a class="srclink" href="../../src/bytes/buf/buf_mut.rs.html#1072-1074" title="goto source code">[src]</a></h4></div><span class="loading-content">Loading content...</span><h2 id="implementors" class="small-section-header">Implementors<a href="#implementors" class="anchor"></a></h2><div class="item-list" id="implementors-list"><h3 id="impl-BufMut" class="impl"><code class="in-band">impl BufMut for <a class="struct" href="../../bytes/struct.BytesMut.html" title="struct bytes::BytesMut">BytesMut</a></code><a href="#impl-BufMut" class="anchor"></a><a class="srclink" href="../../src/bytes/bytes_mut.rs.html#969-1013" title="goto source code">[src]</a></h3><div class="impl-items"><h4 id="method.remaining_mut-4" class="method hidden"><code>fn <a href="#method.remaining_mut-4" class="fnname">remaining_mut</a>(&amp;self) -&gt; <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.usize.html">usize</a></code><a class="srclink" href="../../src/bytes/bytes_mut.rs.html#971-973" title="goto source code">[src]</a></h4><h4 id="method.advance_mut-4" class="method hidden"><code>unsafe fn <a href="#method.advance_mut-4" class="fnname">advance_mut</a>(&amp;mut self, cnt: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.usize.html">usize</a>)</code><a class="srclink" href="../../src/bytes/bytes_mut.rs.html#976-985" title="goto source code">[src]</a></h4><h4 id="method.chunk_mut-4" class="method hidden"><code>fn <a href="#method.chunk_mut-4" class="fnname">chunk_mut</a>(&amp;mut self) -&gt; &amp;mut <a class="struct" href="../../bytes/buf/struct.UninitSlice.html" title="struct bytes::buf::UninitSlice">UninitSlice</a></code><a class="srclink" href="../../src/bytes/bytes_mut.rs.html#988-993" title="goto source code">[src]</a></h4><h4 id="method.put-2" class="method hidden"><code>fn <a href="#method.put-2" class="fnname">put</a>&lt;T:&nbsp;<a class="trait" href="../../bytes/buf/trait.Buf.html" title="trait bytes::buf::Buf">Buf</a>&gt;(&amp;mut self, src: T) <span class="where fmt-newline">where<br>&nbsp;&nbsp;&nbsp;&nbsp;Self: <a class="trait" href="https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html" title="trait core::marker::Sized">Sized</a>,&nbsp;</span></code><a class="srclink" href="../../src/bytes/bytes_mut.rs.html#998-1008" title="goto source code">[src]</a></h4><h4 id="method.put_slice-4" class="method hidden"><code>fn <a href="#method.put_slice-4" class="fnname">put_slice</a>(&amp;mut self, src: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.slice.html">&amp;[</a><a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.u8.html">u8</a><a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.slice.html">]</a>)</code><a class="srclink" href="../../src/bytes/bytes_mut.rs.html#1010-1012" title="goto source code">[src]</a></h4></div><h3 id="impl-BufMut-1" class="impl"><code class="in-band">impl&lt;T, U&gt; BufMut for <a class="struct" href="../../bytes/buf/struct.Chain.html" title="struct bytes::buf::Chain">Chain</a>&lt;T, U&gt; <span class="where fmt-newline">where<br>&nbsp;&nbsp;&nbsp;&nbsp;T: <a class="trait" href="../../bytes/buf/trait.BufMut.html" title="trait bytes::buf::BufMut">BufMut</a>,<br>&nbsp;&nbsp;&nbsp;&nbsp;U: <a class="trait" href="../../bytes/buf/trait.BufMut.html" title="trait bytes::buf::BufMut">BufMut</a>,&nbsp;</span></code><a href="#impl-BufMut-1" class="anchor"></a><a class="srclink" href="../../src/bytes/buf/chain.rs.html#175-209" title="goto source code">[src]</a></h3><div class="impl-items"><h4 id="method.remaining_mut-5" class="method hidden"><code>fn <a href="#method.remaining_mut-5" class="fnname">remaining_mut</a>(&amp;self) -&gt; <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.usize.html">usize</a></code><a class="srclink" href="../../src/bytes/buf/chain.rs.html#180-182" title="goto source code">[src]</a></h4><h4 id="method.chunk_mut-5" class="method hidden"><code>fn <a href="#method.chunk_mut-5" class="fnname">chunk_mut</a>(&amp;mut self) -&gt; &amp;mut <a class="struct" href="../../bytes/buf/struct.UninitSlice.html" title="struct bytes::buf::UninitSlice">UninitSlice</a></code><a class="srclink" href="../../src/bytes/buf/chain.rs.html#184-190" title="goto source code">[src]</a></h4><h4 id="method.advance_mut-5" class="method hidden"><code>unsafe fn <a href="#method.advance_mut-5" class="fnname">advance_mut</a>(&amp;mut self, cnt: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.usize.html">usize</a>)</code><a class="srclink" href="../../src/bytes/buf/chain.rs.html#192-208" title="goto source code">[src]</a></h4></div><h3 id="impl-BufMut-2" class="impl"><code class="in-band">impl&lt;T:&nbsp;<a class="trait" href="../../bytes/buf/trait.BufMut.html" title="trait bytes::buf::BufMut">BufMut</a>&gt; BufMut for <a class="struct" href="../../bytes/buf/struct.Limit.html" title="struct bytes::buf::Limit">Limit</a>&lt;T&gt;</code><a href="#impl-BufMut-2" class="anchor"></a><a class="srclink" href="../../src/bytes/buf/limit.rs.html#59-75" title="goto source code">[src]</a></h3><div class="impl-items"><h4 id="method.remaining_mut-6" class="method hidden"><code>fn <a href="#method.remaining_mut-6" class="fnname">remaining_mut</a>(&amp;self) -&gt; <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.usize.html">usize</a></code><a class="srclink" href="../../src/bytes/buf/limit.rs.html#60-62" title="goto source code">[src]</a></h4><h4 id="method.chunk_mut-6" class="method hidden"><code>fn <a href="#method.chunk_mut-6" class="fnname">chunk_mut</a>(&amp;mut self) -&gt; &amp;mut <a class="struct" href="../../bytes/buf/struct.UninitSlice.html" title="struct bytes::buf::UninitSlice">UninitSlice</a></code><a class="srclink" href="../../src/bytes/buf/limit.rs.html#64-68" title="goto source code">[src]</a></h4><h4 id="method.advance_mut-6" class="method hidden"><code>unsafe fn <a href="#method.advance_mut-6" class="fnname">advance_mut</a>(&amp;mut self, cnt: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.usize.html">usize</a>)</code><a class="srclink" href="../../src/bytes/buf/limit.rs.html#70-74" title="goto source code">[src]</a></h4></div></div><span class="loading-content">Loading content...</span><script type="text/javascript" src="../../implementors/bytes/buf/trait.BufMut.js" async></script></section><section id="search" class="content hidden"></section><section class="footer"></section><div id="rustdoc-vars" data-root-path="../../" data-current-crate="bytes"></div>
<script src="../../main.js"></script><script defer src="../../search-index.js"></script></body></html>
Reference in New Issue View Git Blame Copy Permalink