forked from diesel-rs/diesel
-
Notifications
You must be signed in to change notification settings - Fork 0
Expand file tree
/
Copy pathstruct.Uuid.html
More file actions
556 lines (491 loc) · 148 KB
/
Copy pathstruct.Uuid.html
File metadata and controls
556 lines (491 loc) · 148 KB
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
<!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="A Universally Unique Identifier (UUID)."><meta name="keywords" content="rust, rustlang, rust-lang, Uuid"><title>Uuid in uuid - Rust</title><link rel="preload" as="font" type="font/woff2" crossorigin href="../SourceSerif4-Regular.ttf.woff2"><link rel="preload" as="font" type="font/woff2" crossorigin href="../FiraSans-Regular.woff2"><link rel="preload" as="font" type="font/woff2" crossorigin href="../FiraSans-Medium.woff2"><link rel="preload" as="font" type="font/woff2" crossorigin href="../SourceCodePro-Regular.ttf.woff2"><link rel="preload" as="font" type="font/woff2" crossorigin href="../SourceSerif4-Bold.ttf.woff2"><link rel="preload" as="font" type="font/woff2" crossorigin href="../SourceCodePro-Semibold.ttf.woff2"><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="../ayu.css" disabled><link rel="stylesheet" type="text/css" href="../dark.css" disabled><link rel="stylesheet" type="text/css" href="../light.css" id="themeStyle"><script id="default-settings" ></script><script src="../storage.js"></script><script src="../crates.js"></script><script defer src="../main.js"></script>
<noscript><link rel="stylesheet" href="../noscript.css"></noscript><link rel="icon" href="https://www.rust-lang.org/favicon.ico"></head><body class="rustdoc struct"><!--[if lte IE 11]><div class="warning">This old browser is unsupported and will most likely display funky things.</div><![endif]--><nav class="mobile-topbar"><button class="sidebar-menu-toggle">☰</button><a class="sidebar-logo" href="../uuid/index.html"><div class="logo-container"><img src="https://www.rust-lang.org/logos/rust-logo-128x128-blk-v2.png" alt="logo"></div>
</a><h2 class="location"></h2>
</nav>
<nav class="sidebar"><a class="sidebar-logo" href="../uuid/index.html"><div class="logo-container">
<img src="https://www.rust-lang.org/logos/rust-logo-128x128-blk-v2.png" alt="logo"></div>
</a><h2 class="location"><a href="#">Uuid</a></h2><div class="sidebar-elems"><section><div class="block"><h3 class="sidebar-title"><a href="#implementations">Associated Constants</a></h3><ul><li><a href="#associatedconstant.NAMESPACE_DNS">NAMESPACE_DNS</a></li><li><a href="#associatedconstant.NAMESPACE_OID">NAMESPACE_OID</a></li><li><a href="#associatedconstant.NAMESPACE_URL">NAMESPACE_URL</a></li><li><a href="#associatedconstant.NAMESPACE_X500">NAMESPACE_X500</a></li></ul></div><div class="block"><h3 class="sidebar-title"><a href="#implementations">Methods</a></h3><ul><li><a href="#method.as_braced">as_braced</a></li><li><a href="#method.as_bytes">as_bytes</a></li><li><a href="#method.as_fields">as_fields</a></li><li><a href="#method.as_hyphenated">as_hyphenated</a></li><li><a href="#method.as_simple">as_simple</a></li><li><a href="#method.as_u128">as_u128</a></li><li><a href="#method.as_u64_pair">as_u64_pair</a></li><li><a href="#method.as_urn">as_urn</a></li><li><a href="#method.braced">braced</a></li><li><a href="#method.encode_buffer">encode_buffer</a></li><li><a href="#method.from_bytes">from_bytes</a></li><li><a href="#method.from_bytes_le">from_bytes_le</a></li><li><a href="#method.from_bytes_ref">from_bytes_ref</a></li><li><a href="#method.from_fields">from_fields</a></li><li><a href="#method.from_fields_le">from_fields_le</a></li><li><a href="#method.from_slice">from_slice</a></li><li><a href="#method.from_slice_le">from_slice_le</a></li><li><a href="#method.from_u128">from_u128</a></li><li><a href="#method.from_u128_le">from_u128_le</a></li><li><a href="#method.from_u64_pair">from_u64_pair</a></li><li><a href="#method.get_variant">get_variant</a></li><li><a href="#method.get_version">get_version</a></li><li><a href="#method.get_version_num">get_version_num</a></li><li><a href="#method.hyphenated">hyphenated</a></li><li><a href="#method.into_bytes">into_bytes</a></li><li><a href="#method.is_nil">is_nil</a></li><li><a href="#method.nil">nil</a></li><li><a href="#method.parse_str">parse_str</a></li><li><a href="#method.simple">simple</a></li><li><a href="#method.to_fields_le">to_fields_le</a></li><li><a href="#method.to_u128_le">to_u128_le</a></li><li><a href="#method.try_parse">try_parse</a></li><li><a href="#method.try_parse_ascii">try_parse_ascii</a></li><li><a href="#method.urn">urn</a></li></ul></div><div class="block"><h3 class="sidebar-title"><a href="#trait-implementations">Trait Implementations</a></h3><ul><li><a href="#impl-AsRef%3C%5Bu8%5D%3E">AsRef<[u8]></a></li><li><a href="#impl-AsRef%3CUuid%3E">AsRef<Uuid></a></li><li><a href="#impl-AsRef%3CUuid%3E-1">AsRef<Uuid></a></li><li><a href="#impl-AsRef%3CUuid%3E-2">AsRef<Uuid></a></li><li><a href="#impl-AsRef%3CUuid%3E-3">AsRef<Uuid></a></li><li><a href="#impl-Borrow%3CUuid%3E">Borrow<Uuid></a></li><li><a href="#impl-Borrow%3CUuid%3E-1">Borrow<Uuid></a></li><li><a href="#impl-Borrow%3CUuid%3E-2">Borrow<Uuid></a></li><li><a href="#impl-Borrow%3CUuid%3E-3">Borrow<Uuid></a></li><li><a href="#impl-Clone">Clone</a></li><li><a href="#impl-Copy">Copy</a></li><li><a href="#impl-Debug">Debug</a></li><li><a href="#impl-Default">Default</a></li><li><a href="#impl-Display">Display</a></li><li><a href="#impl-Eq">Eq</a></li><li><a href="#impl-From%3CBraced%3E">From<Braced></a></li><li><a href="#impl-From%3CHyphenated%3E">From<Hyphenated></a></li><li><a href="#impl-From%3CSimple%3E">From<Simple></a></li><li><a href="#impl-From%3CUrn%3E">From<Urn></a></li><li><a href="#impl-From%3CUuid%3E">From<Uuid></a></li><li><a href="#impl-From%3CUuid%3E-1">From<Uuid></a></li><li><a href="#impl-From%3CUuid%3E-2">From<Uuid></a></li><li><a href="#impl-From%3CUuid%3E-3">From<Uuid></a></li><li><a href="#impl-FromStr">FromStr</a></li><li><a href="#impl-Hash">Hash</a></li><li><a href="#impl-LowerHex">LowerHex</a></li><li><a href="#impl-Ord">Ord</a></li><li><a href="#impl-PartialEq%3CUuid%3E">PartialEq<Uuid></a></li><li><a href="#impl-PartialOrd%3CUuid%3E">PartialOrd<Uuid></a></li><li><a href="#impl-StructuralEq">StructuralEq</a></li><li><a href="#impl-StructuralPartialEq">StructuralPartialEq</a></li><li><a href="#impl-TryFrom%3C%26%27_%20str%3E">TryFrom<&'_ str></a></li><li><a href="#impl-UpperHex">UpperHex</a></li></ul></div><div class="block"><h3 class="sidebar-title"><a href="#synthetic-implementations">Auto Trait Implementations</a></h3><ul><li><a href="#impl-RefUnwindSafe">RefUnwindSafe</a></li><li><a href="#impl-Send">Send</a></li><li><a href="#impl-Sync">Sync</a></li><li><a href="#impl-Unpin">Unpin</a></li><li><a href="#impl-UnwindSafe">UnwindSafe</a></li></ul></div><div class="block"><h3 class="sidebar-title"><a href="#blanket-implementations">Blanket Implementations</a></h3><ul><li><a href="#impl-Any">Any</a></li><li><a href="#impl-Borrow%3CT%3E">Borrow<T></a></li><li><a href="#impl-BorrowMut%3CT%3E">BorrowMut<T></a></li><li><a href="#impl-From%3CT%3E">From<T></a></li><li><a href="#impl-Into%3CU%3E">Into<U></a></li><li><a href="#impl-ToOwned">ToOwned</a></li><li><a href="#impl-ToString">ToString</a></li><li><a href="#impl-TryFrom%3CU%3E">TryFrom<U></a></li><li><a href="#impl-TryInto%3CU%3E">TryInto<U></a></li></ul></div></section><h2 class="location"><a href="index.html">In uuid</a></h2><div id="sidebar-vars" data-name="Uuid" data-ty="struct" data-relpath=""></div><script defer src="sidebar-items.js"></script></div></nav><main><div class="width-limiter"><div class="sub-container"><a class="sub-logo-container" href="../uuid/index.html">
<img src="https://www.rust-lang.org/logos/rust-logo-128x128-blk-v2.png" alt="logo"></a><nav class="sub"><div class="theme-picker hidden"><button id="theme-picker" aria-label="Pick another theme!" aria-haspopup="menu" title="themes"><img width="22" height="22" alt="Pick another theme!" src="../brush.svg"></button><div id="theme-choices" role="menu"></div></div><form class="search-form"><div class="search-container"><span></span><input class="search-input" name="search" autocomplete="off" spellcheck="false" placeholder="Click or press ‘S’ to search, ‘?’ for more options…" type="search"><button type="button" id="help-button" title="help">?</button><a id="settings-menu" href="../settings.html" title="settings"><img width="22" height="22" alt="Change settings" src="../wheel.svg"></a></div></form></nav></div><section id="main-content" class="content"><div class="main-heading">
<h1 class="fqn"><span class="in-band">Struct <a href="index.html">uuid</a>::<wbr><a class="struct" href="#">Uuid</a><button id="copy-path" onclick="copy_path(this)" title="Copy item path to clipboard"><img src="../clipboard.svg" width="19" height="18" alt="Copy item path"></button></span></h1><span class="out-of-band"><a class="srclink" href="../src/uuid/lib.rs.html#403">source</a> · <a id="toggle-all-docs" href="javascript:void(0)" title="collapse all docs">[<span class="inner">−</span>]</a></span></div><div class="docblock item-decl"><pre class="rust struct"><code><div class="code-attribute">#[repr(transparent)]</div>pub struct Uuid(_);</code></pre></div><details class="rustdoc-toggle top-doc" open><summary class="hideme"><span>Expand description</span></summary><div class="docblock"><p>A Universally Unique Identifier (UUID).</p>
<h2 id="examples"><a href="#examples">Examples</a></h2>
<p>Parse a UUID given in the simple format and print it as a urn:</p>
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">let</span> <span class="ident">my_uuid</span> <span class="op">=</span> <span class="ident">Uuid::parse_str</span>(<span class="string">"a1a2a3a4b1b2c1c2d1d2d3d4d5d6d7d8"</span>)<span class="question-mark">?</span>;
<span class="macro">println!</span>(<span class="string">"{}"</span>, <span class="ident">my_uuid</span>.<span class="ident">urn</span>());</code></pre></div>
<p>Create a new random (V4) UUID and print it out in hexadecimal form:</p>
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="comment">// Note that this requires the `v4` feature enabled in the uuid crate.</span>
<span class="kw">let</span> <span class="ident">my_uuid</span> <span class="op">=</span> <span class="ident">Uuid::new_v4</span>();
<span class="macro">println!</span>(<span class="string">"{}"</span>, <span class="ident">my_uuid</span>);</code></pre></div>
<h2 id="formatting"><a href="#formatting">Formatting</a></h2>
<p>A UUID can be formatted in one of a few ways:</p>
<ul>
<li><a href="#method.to_simple"><code>simple</code></a>: <code>a1a2a3a4b1b2c1c2d1d2d3d4d5d6d7d8</code>.</li>
<li><a href="#method.hyphenated"><code>hyphenated</code></a>:
<code>a1a2a3a4-b1b2-c1c2-d1d2-d3d4d5d6d7d8</code>.</li>
<li><a href="#method.to_urn"><code>urn</code></a>: <code>urn:uuid:A1A2A3A4-B1B2-C1C2-D1D2-D3D4D5D6D7D8</code>.</li>
<li><a href="#method.braced"><code>braced</code></a>: <code>{a1a2a3a4-b1b2-c1c2-d1d2-d3d4d5d6d7d8}</code>.</li>
</ul>
<p>The default representation when formatting a UUID with <code>Display</code> is
hyphenated:</p>
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">let</span> <span class="ident">my_uuid</span> <span class="op">=</span> <span class="ident">Uuid::parse_str</span>(<span class="string">"a1a2a3a4b1b2c1c2d1d2d3d4d5d6d7d8"</span>)<span class="question-mark">?</span>;
<span class="macro">assert_eq!</span>(
<span class="string">"a1a2a3a4-b1b2-c1c2-d1d2-d3d4d5d6d7d8"</span>,
<span class="ident">my_uuid</span>.<span class="ident">to_string</span>(),
);</code></pre></div>
<p>Other formats can be specified using adapter methods on the UUID:</p>
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">let</span> <span class="ident">my_uuid</span> <span class="op">=</span> <span class="ident">Uuid::parse_str</span>(<span class="string">"a1a2a3a4b1b2c1c2d1d2d3d4d5d6d7d8"</span>)<span class="question-mark">?</span>;
<span class="macro">assert_eq!</span>(
<span class="string">"urn:uuid:a1a2a3a4-b1b2-c1c2-d1d2-d3d4d5d6d7d8"</span>,
<span class="ident">my_uuid</span>.<span class="ident">urn</span>().<span class="ident">to_string</span>(),
);</code></pre></div>
<h2 id="endianness"><a href="#endianness">Endianness</a></h2>
<p>The specification for UUIDs encodes the integer fields that make up the
value in big-endian order. This crate assumes integer inputs are already in
the correct order by default, regardless of the endianness of the
environment. Most methods that accept integers have a <code>_le</code> variant (such as
<code>from_fields_le</code>) that assumes any integer values will need to have their
bytes flipped, regardless of the endianness of the environment.</p>
<p>Most users won’t need to worry about endianness unless they need to operate
on individual fields (such as when converting between Microsoft GUIDs). The
important things to remember are:</p>
<ul>
<li>The endianness is in terms of the fields of the UUID, not the environment.</li>
<li>The endianness is assumed to be big-endian when there’s no <code>_le</code> suffix
somewhere.</li>
<li>Byte-flipping in <code>_le</code> methods applies to each integer.</li>
<li>Endianness roundtrips, so if you create a UUID with <code>from_fields_le</code>
you’ll get the same values back out with <code>to_fields_le</code>.</li>
</ul>
<h2 id="abi"><a href="#abi">ABI</a></h2>
<p>The <code>Uuid</code> type is always guaranteed to be have the same ABI as <a href="type.Bytes.html" title="Bytes"><code>Bytes</code></a>.</p>
</div></details><h2 id="implementations" class="small-section-header">Implementations<a href="#implementations" class="anchor"></a></h2><div id="implementations-list"><details class="rustdoc-toggle implementors-toggle" open><summary><section id="impl" class="impl has-srclink"><span class="rightside"><a class="srclink" href="../src/uuid/builder.rs.html#45-461">source</a></span><a href="#impl" class="anchor"></a><h3 class="code-header in-band">impl <a class="struct" href="struct.Uuid.html" title="struct uuid::Uuid">Uuid</a></h3></section></summary><div class="impl-items"><details class="rustdoc-toggle method-toggle" open><summary><section id="method.nil" class="method has-srclink"><span class="rightside"><a class="srclink" href="../src/uuid/builder.rs.html#66-68">source</a></span><a href="#method.nil" class="anchor"></a><h4 class="code-header">pub const fn <a href="#method.nil" class="fnname">nil</a>() -> Self</h4></section></summary><div class="docblock"><p>The ‘nil UUID’.</p>
<p>The nil UUID is a special form of UUID that is specified to have all
128 bits set to zero, as defined in <a href="https://tools.ietf.org/html/rfc4122.html#section-4.1.7">IETF RFC 4122 Section 4.1.7</a>.</p>
<h5 id="examples-1"><a href="#examples-1">Examples</a></h5>
<p>Basic usage:</p>
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">let</span> <span class="ident">uuid</span> <span class="op">=</span> <span class="ident">Uuid::nil</span>();
<span class="macro">assert_eq!</span>(
<span class="string">"00000000-0000-0000-0000-000000000000"</span>,
<span class="ident">uuid</span>.<span class="ident">hyphenated</span>().<span class="ident">to_string</span>(),
);</code></pre></div>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><section id="method.from_fields" class="method has-srclink"><span class="rightside"><a class="srclink" href="../src/uuid/builder.rs.html#90-109">source</a></span><a href="#method.from_fields" class="anchor"></a><h4 class="code-header">pub const fn <a href="#method.from_fields" class="fnname">from_fields</a>(d1: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.u32.html">u32</a>, d2: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.u16.html">u16</a>, d3: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.u16.html">u16</a>, d4: &<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.array.html">[</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.array.html">; 8]</a>) -> <a class="struct" href="struct.Uuid.html" title="struct uuid::Uuid">Uuid</a></h4></section></summary><div class="docblock"><p>Creates a UUID from four field values.</p>
<h5 id="examples-2"><a href="#examples-2">Examples</a></h5>
<p>Basic usage:</p>
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">let</span> <span class="ident">d1</span> <span class="op">=</span> <span class="number">0xa1a2a3a4</span>;
<span class="kw">let</span> <span class="ident">d2</span> <span class="op">=</span> <span class="number">0xb1b2</span>;
<span class="kw">let</span> <span class="ident">d3</span> <span class="op">=</span> <span class="number">0xc1c2</span>;
<span class="kw">let</span> <span class="ident">d4</span> <span class="op">=</span> [<span class="number">0xd1</span>, <span class="number">0xd2</span>, <span class="number">0xd3</span>, <span class="number">0xd4</span>, <span class="number">0xd5</span>, <span class="number">0xd6</span>, <span class="number">0xd7</span>, <span class="number">0xd8</span>];
<span class="kw">let</span> <span class="ident">uuid</span> <span class="op">=</span> <span class="ident">Uuid::from_fields</span>(<span class="ident">d1</span>, <span class="ident">d2</span>, <span class="ident">d3</span>, <span class="kw-2">&</span><span class="ident">d4</span>);
<span class="macro">assert_eq!</span>(
<span class="string">"a1a2a3a4-b1b2-c1c2-d1d2-d3d4d5d6d7d8"</span>,
<span class="ident">uuid</span>.<span class="ident">hyphenated</span>().<span class="ident">to_string</span>(),
);</code></pre></div>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><section id="method.from_fields_le" class="method has-srclink"><span class="rightside"><a class="srclink" href="../src/uuid/builder.rs.html#134-158">source</a></span><a href="#method.from_fields_le" class="anchor"></a><h4 class="code-header">pub const fn <a href="#method.from_fields_le" class="fnname">from_fields_le</a>(d1: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.u32.html">u32</a>, d2: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.u16.html">u16</a>, d3: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.u16.html">u16</a>, d4: &<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.array.html">[</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.array.html">; 8]</a>) -> <a class="struct" href="struct.Uuid.html" title="struct uuid::Uuid">Uuid</a></h4></section></summary><div class="docblock"><p>Creates a UUID from four field values in little-endian order.</p>
<p>The bytes in the <code>d1</code>, <code>d2</code> and <code>d3</code> fields will be flipped to convert
into big-endian order. This is based on the endianness of the UUID,
rather than the target environment so bytes will be flipped on both
big and little endian machines.</p>
<h5 id="examples-3"><a href="#examples-3">Examples</a></h5>
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">let</span> <span class="ident">d1</span> <span class="op">=</span> <span class="number">0xa1a2a3a4</span>;
<span class="kw">let</span> <span class="ident">d2</span> <span class="op">=</span> <span class="number">0xb1b2</span>;
<span class="kw">let</span> <span class="ident">d3</span> <span class="op">=</span> <span class="number">0xc1c2</span>;
<span class="kw">let</span> <span class="ident">d4</span> <span class="op">=</span> [<span class="number">0xd1</span>, <span class="number">0xd2</span>, <span class="number">0xd3</span>, <span class="number">0xd4</span>, <span class="number">0xd5</span>, <span class="number">0xd6</span>, <span class="number">0xd7</span>, <span class="number">0xd8</span>];
<span class="kw">let</span> <span class="ident">uuid</span> <span class="op">=</span> <span class="ident">Uuid::from_fields_le</span>(<span class="ident">d1</span>, <span class="ident">d2</span>, <span class="ident">d3</span>, <span class="kw-2">&</span><span class="ident">d4</span>);
<span class="macro">assert_eq!</span>(
<span class="string">"a4a3a2a1-b2b1-c2c1-d1d2-d3d4d5d6d7d8"</span>,
<span class="ident">uuid</span>.<span class="ident">hyphenated</span>().<span class="ident">to_string</span>(),
);</code></pre></div>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><section id="method.from_u128" class="method has-srclink"><span class="rightside"><a class="srclink" href="../src/uuid/builder.rs.html#177-196">source</a></span><a href="#method.from_u128" class="anchor"></a><h4 class="code-header">pub const fn <a href="#method.from_u128" class="fnname">from_u128</a>(v: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.u128.html">u128</a>) -> Self</h4></section></summary><div class="docblock"><p>Creates a UUID from a 128bit value.</p>
<h5 id="examples-4"><a href="#examples-4">Examples</a></h5>
<p>Basic usage:</p>
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">let</span> <span class="ident">v</span> <span class="op">=</span> <span class="number">0xa1a2a3a4b1b2c1c2d1d2d3d4d5d6d7d8u128</span>;
<span class="kw">let</span> <span class="ident">uuid</span> <span class="op">=</span> <span class="ident">Uuid::from_u128</span>(<span class="ident">v</span>);
<span class="macro">assert_eq!</span>(
<span class="string">"a1a2a3a4-b1b2-c1c2-d1d2-d3d4d5d6d7d8"</span>,
<span class="ident">uuid</span>.<span class="ident">hyphenated</span>().<span class="ident">to_string</span>(),
);</code></pre></div>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><section id="method.from_u128_le" class="method has-srclink"><span class="rightside"><a class="srclink" href="../src/uuid/builder.rs.html#220-239">source</a></span><a href="#method.from_u128_le" class="anchor"></a><h4 class="code-header">pub const fn <a href="#method.from_u128_le" class="fnname">from_u128_le</a>(v: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.u128.html">u128</a>) -> Self</h4></section></summary><div class="docblock"><p>Creates a UUID from a 128bit value in little-endian order.</p>
<p>The entire value will be flipped to convert into big-endian order.
This is based on the endianness of the UUID, rather than the target
environment so bytes will be flipped on both big and little endian
machines.</p>
<h5 id="examples-5"><a href="#examples-5">Examples</a></h5>
<p>Basic usage:</p>
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">let</span> <span class="ident">v</span> <span class="op">=</span> <span class="number">0xa1a2a3a4b1b2c1c2d1d2d3d4d5d6d7d8u128</span>;
<span class="kw">let</span> <span class="ident">uuid</span> <span class="op">=</span> <span class="ident">Uuid::from_u128_le</span>(<span class="ident">v</span>);
<span class="macro">assert_eq!</span>(
<span class="string">"d8d7d6d5-d4d3-d2d1-c2c1-b2b1a4a3a2a1"</span>,
<span class="ident">uuid</span>.<span class="ident">hyphenated</span>().<span class="ident">to_string</span>(),
);</code></pre></div>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><section id="method.from_u64_pair" class="method has-srclink"><span class="rightside"><a class="srclink" href="../src/uuid/builder.rs.html#259-278">source</a></span><a href="#method.from_u64_pair" class="anchor"></a><h4 class="code-header">pub const fn <a href="#method.from_u64_pair" class="fnname">from_u64_pair</a>(high_bits: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.u64.html">u64</a>, low_bits: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.u64.html">u64</a>) -> Self</h4></section></summary><div class="docblock"><p>Creates a UUID from two 64bit values.</p>
<h5 id="examples-6"><a href="#examples-6">Examples</a></h5>
<p>Basic usage:</p>
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">let</span> <span class="ident">hi</span> <span class="op">=</span> <span class="number">0xa1a2a3a4b1b2c1c2u64</span>;
<span class="kw">let</span> <span class="ident">lo</span> <span class="op">=</span> <span class="number">0xd1d2d3d4d5d6d7d8u64</span>;
<span class="kw">let</span> <span class="ident">uuid</span> <span class="op">=</span> <span class="ident">Uuid::from_u64_pair</span>(<span class="ident">hi</span>, <span class="ident">lo</span>);
<span class="macro">assert_eq!</span>(
<span class="string">"a1a2a3a4-b1b2-c1c2-d1d2-d3d4d5d6d7d8"</span>,
<span class="ident">uuid</span>.<span class="ident">hyphenated</span>().<span class="ident">to_string</span>(),
);</code></pre></div>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><section id="method.from_slice" class="method has-srclink"><span class="rightside"><a class="srclink" href="../src/uuid/builder.rs.html#309-317">source</a></span><a href="#method.from_slice" class="anchor"></a><h4 class="code-header">pub fn <a href="#method.from_slice" class="fnname">from_slice</a>(b: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.slice.html">&[</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>) -> <a class="enum" href="https://doc.rust-lang.org/nightly/core/result/enum.Result.html" title="enum core::result::Result">Result</a><<a class="struct" href="struct.Uuid.html" title="struct uuid::Uuid">Uuid</a>, <a class="struct" href="struct.Error.html" title="struct uuid::Error">Error</a>></h4></section></summary><div class="docblock"><p>Creates a UUID using the supplied bytes.</p>
<h5 id="errors"><a href="#errors">Errors</a></h5>
<p>This function will return an error if <code>b</code> has any length other than 16.</p>
<h5 id="examples-7"><a href="#examples-7">Examples</a></h5>
<p>Basic usage:</p>
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">let</span> <span class="ident">bytes</span> <span class="op">=</span> [
<span class="number">0xa1</span>, <span class="number">0xa2</span>, <span class="number">0xa3</span>, <span class="number">0xa4</span>,
<span class="number">0xb1</span>, <span class="number">0xb2</span>,
<span class="number">0xc1</span>, <span class="number">0xc2</span>,
<span class="number">0xd1</span>, <span class="number">0xd2</span>, <span class="number">0xd3</span>, <span class="number">0xd4</span>, <span class="number">0xd5</span>, <span class="number">0xd6</span>, <span class="number">0xd7</span>, <span class="number">0xd8</span>,
];
<span class="kw">let</span> <span class="ident">uuid</span> <span class="op">=</span> <span class="ident">Uuid::from_slice</span>(<span class="kw-2">&</span><span class="ident">bytes</span>)<span class="question-mark">?</span>;
<span class="macro">assert_eq!</span>(
<span class="string">"a1a2a3a4-b1b2-c1c2-d1d2-d3d4d5d6d7d8"</span>,
<span class="ident">uuid</span>.<span class="ident">hyphenated</span>().<span class="ident">to_string</span>(),
);</code></pre></div>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><section id="method.from_slice_le" class="method has-srclink"><span class="rightside"><a class="srclink" href="../src/uuid/builder.rs.html#350-358">source</a></span><a href="#method.from_slice_le" class="anchor"></a><h4 class="code-header">pub fn <a href="#method.from_slice_le" class="fnname">from_slice_le</a>(b: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.slice.html">&[</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>) -> <a class="enum" href="https://doc.rust-lang.org/nightly/core/result/enum.Result.html" title="enum core::result::Result">Result</a><<a class="struct" href="struct.Uuid.html" title="struct uuid::Uuid">Uuid</a>, <a class="struct" href="struct.Error.html" title="struct uuid::Error">Error</a>></h4></section></summary><div class="docblock"><p>Creates a UUID using the supplied bytes in little endian order.</p>
<p>The individual fields encoded in the buffer will be flipped.</p>
<h5 id="errors-1"><a href="#errors-1">Errors</a></h5>
<p>This function will return an error if <code>b</code> has any length other than 16.</p>
<h5 id="examples-8"><a href="#examples-8">Examples</a></h5>
<p>Basic usage:</p>
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">let</span> <span class="ident">bytes</span> <span class="op">=</span> [
<span class="number">0xa1</span>, <span class="number">0xa2</span>, <span class="number">0xa3</span>, <span class="number">0xa4</span>,
<span class="number">0xb1</span>, <span class="number">0xb2</span>,
<span class="number">0xc1</span>, <span class="number">0xc2</span>,
<span class="number">0xd1</span>, <span class="number">0xd2</span>, <span class="number">0xd3</span>, <span class="number">0xd4</span>, <span class="number">0xd5</span>, <span class="number">0xd6</span>, <span class="number">0xd7</span>, <span class="number">0xd8</span>,
];
<span class="kw">let</span> <span class="ident">uuid</span> <span class="op">=</span> <span class="ident">Uuid::from_slice_le</span>(<span class="kw-2">&</span><span class="ident">bytes</span>)<span class="question-mark">?</span>;
<span class="macro">assert_eq!</span>(
<span class="ident">uuid</span>.<span class="ident">hyphenated</span>().<span class="ident">to_string</span>(),
<span class="string">"a4a3a2a1-b2b1-c2c1-d1d2-d3d4d5d6d7d8"</span>
);</code></pre></div>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><section id="method.from_bytes" class="method has-srclink"><span class="rightside"><a class="srclink" href="../src/uuid/builder.rs.html#385-387">source</a></span><a href="#method.from_bytes" class="anchor"></a><h4 class="code-header">pub const fn <a href="#method.from_bytes" class="fnname">from_bytes</a>(bytes: <a class="type" href="type.Bytes.html" title="type uuid::Bytes">Bytes</a>) -> <a class="struct" href="struct.Uuid.html" title="struct uuid::Uuid">Uuid</a></h4></section></summary><div class="docblock"><p>Creates a UUID using the supplied bytes.</p>
<h5 id="examples-9"><a href="#examples-9">Examples</a></h5>
<p>Basic usage:</p>
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">let</span> <span class="ident">bytes</span> <span class="op">=</span> [
<span class="number">0xa1</span>, <span class="number">0xa2</span>, <span class="number">0xa3</span>, <span class="number">0xa4</span>,
<span class="number">0xb1</span>, <span class="number">0xb2</span>,
<span class="number">0xc1</span>, <span class="number">0xc2</span>,
<span class="number">0xd1</span>, <span class="number">0xd2</span>, <span class="number">0xd3</span>, <span class="number">0xd4</span>, <span class="number">0xd5</span>, <span class="number">0xd6</span>, <span class="number">0xd7</span>, <span class="number">0xd8</span>,
];
<span class="kw">let</span> <span class="ident">uuid</span> <span class="op">=</span> <span class="ident">Uuid::from_bytes</span>(<span class="ident">bytes</span>);
<span class="macro">assert_eq!</span>(
<span class="ident">uuid</span>.<span class="ident">hyphenated</span>().<span class="ident">to_string</span>(),
<span class="string">"a1a2a3a4-b1b2-c1c2-d1d2-d3d4d5d6d7d8"</span>
);</code></pre></div>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><section id="method.from_bytes_le" class="method has-srclink"><span class="rightside"><a class="srclink" href="../src/uuid/builder.rs.html#416-421">source</a></span><a href="#method.from_bytes_le" class="anchor"></a><h4 class="code-header">pub const fn <a href="#method.from_bytes_le" class="fnname">from_bytes_le</a>(b: <a class="type" href="type.Bytes.html" title="type uuid::Bytes">Bytes</a>) -> <a class="struct" href="struct.Uuid.html" title="struct uuid::Uuid">Uuid</a></h4></section></summary><div class="docblock"><p>Creates a UUID using the supplied bytes in little endian order.</p>
<p>The individual fields encoded in the buffer will be flipped.</p>
<h5 id="examples-10"><a href="#examples-10">Examples</a></h5>
<p>Basic usage:</p>
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">let</span> <span class="ident">bytes</span> <span class="op">=</span> [
<span class="number">0xa1</span>, <span class="number">0xa2</span>, <span class="number">0xa3</span>, <span class="number">0xa4</span>,
<span class="number">0xb1</span>, <span class="number">0xb2</span>,
<span class="number">0xc1</span>, <span class="number">0xc2</span>,
<span class="number">0xd1</span>, <span class="number">0xd2</span>, <span class="number">0xd3</span>, <span class="number">0xd4</span>, <span class="number">0xd5</span>, <span class="number">0xd6</span>, <span class="number">0xd7</span>, <span class="number">0xd8</span>,
];
<span class="kw">let</span> <span class="ident">uuid</span> <span class="op">=</span> <span class="ident">Uuid::from_bytes_le</span>(<span class="ident">bytes</span>);
<span class="macro">assert_eq!</span>(
<span class="string">"a4a3a2a1-b2b1-c2c1-d1d2-d3d4d5d6d7d8"</span>,
<span class="ident">uuid</span>.<span class="ident">hyphenated</span>().<span class="ident">to_string</span>(),
);</code></pre></div>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><section id="method.from_bytes_ref" class="method has-srclink"><span class="rightside"><a class="srclink" href="../src/uuid/builder.rs.html#453-456">source</a></span><a href="#method.from_bytes_ref" class="anchor"></a><h4 class="code-header">pub fn <a href="#method.from_bytes_ref" class="fnname">from_bytes_ref</a>(bytes: &<a class="type" href="type.Bytes.html" title="type uuid::Bytes">Bytes</a>) -> &<a class="struct" href="struct.Uuid.html" title="struct uuid::Uuid">Uuid</a></h4></section></summary><div class="docblock"><p>Creates a reference to a UUID from a reference to the supplied bytes.</p>
<h5 id="examples-11"><a href="#examples-11">Examples</a></h5>
<p>Basic usage:</p>
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">let</span> <span class="ident">bytes</span> <span class="op">=</span> [
<span class="number">0xa1</span>, <span class="number">0xa2</span>, <span class="number">0xa3</span>, <span class="number">0xa4</span>,
<span class="number">0xb1</span>, <span class="number">0xb2</span>,
<span class="number">0xc1</span>, <span class="number">0xc2</span>,
<span class="number">0xd1</span>, <span class="number">0xd2</span>, <span class="number">0xd3</span>, <span class="number">0xd4</span>, <span class="number">0xd5</span>, <span class="number">0xd6</span>, <span class="number">0xd7</span>, <span class="number">0xd8</span>,
];
<span class="kw">let</span> <span class="ident">uuid</span> <span class="op">=</span> <span class="ident">Uuid::from_bytes_ref</span>(<span class="kw-2">&</span><span class="ident">bytes</span>);
<span class="macro">assert_eq!</span>(
<span class="ident">uuid</span>.<span class="ident">hyphenated</span>().<span class="ident">to_string</span>(),
<span class="string">"a1a2a3a4-b1b2-c1c2-d1d2-d3d4d5d6d7d8"</span>
);
<span class="macro">assert!</span>(<span class="ident">std::ptr::eq</span>(
<span class="ident">uuid</span> <span class="kw">as</span> <span class="kw-2">*const</span> <span class="ident">Uuid</span> <span class="kw">as</span> <span class="kw-2">*const</span> <span class="ident">u8</span>,
<span class="kw-2">&</span><span class="ident">bytes</span> <span class="kw">as</span> <span class="kw-2">*const</span> [<span class="ident">u8</span>; <span class="number">16</span>] <span class="kw">as</span> <span class="kw-2">*const</span> <span class="ident">u8</span>,
));</code></pre></div>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle" open><summary><section id="impl-1" class="impl has-srclink"><span class="rightside"><a class="srclink" href="../src/uuid/parser.rs.html#38-133">source</a></span><a href="#impl-1" class="anchor"></a><h3 class="code-header in-band">impl <a class="struct" href="struct.Uuid.html" title="struct uuid::Uuid">Uuid</a></h3></section></summary><div class="impl-items"><details class="rustdoc-toggle method-toggle" open><summary><section id="method.parse_str" class="method has-srclink"><span class="rightside"><a class="srclink" href="../src/uuid/parser.rs.html#64-68">source</a></span><a href="#method.parse_str" class="anchor"></a><h4 class="code-header">pub fn <a href="#method.parse_str" class="fnname">parse_str</a>(input: &<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.str.html">str</a>) -> <a class="enum" href="https://doc.rust-lang.org/nightly/core/result/enum.Result.html" title="enum core::result::Result">Result</a><<a class="struct" href="struct.Uuid.html" title="struct uuid::Uuid">Uuid</a>, <a class="struct" href="struct.Error.html" title="struct uuid::Error">Error</a>></h4></section></summary><div class="docblock"><p>Parses a <code>Uuid</code> from a string of hexadecimal digits with optional
hyphens.</p>
<p>Any of the formats generated by this module (simple, hyphenated, urn,
Microsoft GUID) are supported by this parsing function.</p>
<p>Prefer <a href="#method.try_parse"><code>try_parse</code></a> unless you need detailed user-facing diagnostics.
This method will be eventually deprecated in favor of <code>try_parse</code>.</p>
<h5 id="examples-12"><a href="#examples-12">Examples</a></h5>
<p>Parse a hyphenated UUID:</p>
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">let</span> <span class="ident">uuid</span> <span class="op">=</span> <span class="ident">Uuid::parse_str</span>(<span class="string">"550e8400-e29b-41d4-a716-446655440000"</span>)<span class="question-mark">?</span>;
<span class="macro">assert_eq!</span>(<span class="prelude-val">Some</span>(<span class="ident">Version::Random</span>), <span class="ident">uuid</span>.<span class="ident">get_version</span>());
<span class="macro">assert_eq!</span>(<span class="ident">Variant::RFC4122</span>, <span class="ident">uuid</span>.<span class="ident">get_variant</span>());</code></pre></div>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><section id="method.try_parse" class="method has-srclink"><span class="rightside"><a class="srclink" href="../src/uuid/parser.rs.html#98-100">source</a></span><a href="#method.try_parse" class="anchor"></a><h4 class="code-header">pub const fn <a href="#method.try_parse" class="fnname">try_parse</a>(input: &<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.str.html">str</a>) -> <a class="enum" href="https://doc.rust-lang.org/nightly/core/result/enum.Result.html" title="enum core::result::Result">Result</a><<a class="struct" href="struct.Uuid.html" title="struct uuid::Uuid">Uuid</a>, <a class="struct" href="struct.Error.html" title="struct uuid::Error">Error</a>></h4></section></summary><div class="docblock"><p>Parses a <code>Uuid</code> from a string of hexadecimal digits with optional
hyphens.</p>
<p>This function is similar to <a href="#method.parse_str"><code>parse_str</code></a>, in fact <code>parse_str</code> shares
the same underlying parser. The difference is that if <code>try_parse</code>
fails, it won’t generate very useful error messages. The <code>parse_str</code>
function will eventually be deprecated in favor or <code>try_parse</code>.</p>
<p>To parse a UUID from a byte stream instead of a UTF8 string, see
<a href="#method.try_parse_ascii"><code>try_parse_ascii</code></a>.</p>
<h5 id="examples-13"><a href="#examples-13">Examples</a></h5>
<p>Parse a hyphenated UUID:</p>
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">let</span> <span class="ident">uuid</span> <span class="op">=</span> <span class="ident">Uuid::try_parse</span>(<span class="string">"550e8400-e29b-41d4-a716-446655440000"</span>)<span class="question-mark">?</span>;
<span class="macro">assert_eq!</span>(<span class="prelude-val">Some</span>(<span class="ident">Version::Random</span>), <span class="ident">uuid</span>.<span class="ident">get_version</span>());
<span class="macro">assert_eq!</span>(<span class="ident">Variant::RFC4122</span>, <span class="ident">uuid</span>.<span class="ident">get_variant</span>());</code></pre></div>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><section id="method.try_parse_ascii" class="method has-srclink"><span class="rightside"><a class="srclink" href="../src/uuid/parser.rs.html#125-132">source</a></span><a href="#method.try_parse_ascii" class="anchor"></a><h4 class="code-header">pub const fn <a href="#method.try_parse_ascii" class="fnname">try_parse_ascii</a>(input: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.slice.html">&[</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>) -> <a class="enum" href="https://doc.rust-lang.org/nightly/core/result/enum.Result.html" title="enum core::result::Result">Result</a><<a class="struct" href="struct.Uuid.html" title="struct uuid::Uuid">Uuid</a>, <a class="struct" href="struct.Error.html" title="struct uuid::Error">Error</a>></h4></section></summary><div class="docblock"><p>Parses a <code>Uuid</code> from a string of hexadecimal digits with optional
hyphens.</p>
<p>The input is expected to be a string of ASCII characters. This method
can be more convenient than <a href="#method.try_parse"><code>try_parse</code></a> if the UUID is being
parsed from a byte stream instead of from a UTF8 string.</p>
<h5 id="examples-14"><a href="#examples-14">Examples</a></h5>
<p>Parse a hyphenated UUID:</p>
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">let</span> <span class="ident">uuid</span> <span class="op">=</span> <span class="ident">Uuid::try_parse_ascii</span>(<span class="string">b"550e8400-e29b-41d4-a716-446655440000"</span>)<span class="question-mark">?</span>;
<span class="macro">assert_eq!</span>(<span class="prelude-val">Some</span>(<span class="ident">Version::Random</span>), <span class="ident">uuid</span>.<span class="ident">get_version</span>());
<span class="macro">assert_eq!</span>(<span class="ident">Variant::RFC4122</span>, <span class="ident">uuid</span>.<span class="ident">get_variant</span>());</code></pre></div>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle" open><summary><section id="impl-2" class="impl has-srclink"><span class="rightside"><a class="srclink" href="../src/uuid/fmt.rs.html#96-168">source</a></span><a href="#impl-2" class="anchor"></a><h3 class="code-header in-band">impl <a class="struct" href="struct.Uuid.html" title="struct uuid::Uuid">Uuid</a></h3></section></summary><div class="impl-items"><details class="rustdoc-toggle method-toggle" open><summary><section id="method.hyphenated" class="method has-srclink"><span class="rightside"><a class="srclink" href="../src/uuid/fmt.rs.html#101-103">source</a></span><a href="#method.hyphenated" class="anchor"></a><h4 class="code-header">pub const fn <a href="#method.hyphenated" class="fnname">hyphenated</a>(self) -> <a class="struct" href="fmt/struct.Hyphenated.html" title="struct uuid::fmt::Hyphenated">Hyphenated</a></h4></section></summary><div class="docblock"><p>Get a <a href="adapter/struct.Hyphenated.html"><code>Hyphenated</code></a> formatter.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><section id="method.as_hyphenated" class="method has-srclink"><span class="rightside"><a class="srclink" href="../src/uuid/fmt.rs.html#109-112">source</a></span><a href="#method.as_hyphenated" class="anchor"></a><h4 class="code-header">pub fn <a href="#method.as_hyphenated" class="fnname">as_hyphenated</a>(&self) -> &<a class="struct" href="fmt/struct.Hyphenated.html" title="struct uuid::fmt::Hyphenated">Hyphenated</a></h4></section></summary><div class="docblock"><p>Get a borrowed <a href="adapter/struct.Hyphenated.html"><code>Hyphenated</code></a> formatter.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><section id="method.simple" class="method has-srclink"><span class="rightside"><a class="srclink" href="../src/uuid/fmt.rs.html#118-120">source</a></span><a href="#method.simple" class="anchor"></a><h4 class="code-header">pub const fn <a href="#method.simple" class="fnname">simple</a>(self) -> <a class="struct" href="fmt/struct.Simple.html" title="struct uuid::fmt::Simple">Simple</a></h4></section></summary><div class="docblock"><p>Get a <a href="adapter/struct.Simple.html"><code>Simple</code></a> formatter.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><section id="method.as_simple" class="method has-srclink"><span class="rightside"><a class="srclink" href="../src/uuid/fmt.rs.html#126-129">source</a></span><a href="#method.as_simple" class="anchor"></a><h4 class="code-header">pub fn <a href="#method.as_simple" class="fnname">as_simple</a>(&self) -> &<a class="struct" href="fmt/struct.Simple.html" title="struct uuid::fmt::Simple">Simple</a></h4></section></summary><div class="docblock"><p>Get a borrowed <a href="adapter/struct.Simple.html"><code>Simple</code></a> formatter.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><section id="method.urn" class="method has-srclink"><span class="rightside"><a class="srclink" href="../src/uuid/fmt.rs.html#136-138">source</a></span><a href="#method.urn" class="anchor"></a><h4 class="code-header">pub const fn <a href="#method.urn" class="fnname">urn</a>(self) -> <a class="struct" href="fmt/struct.Urn.html" title="struct uuid::fmt::Urn">Urn</a></h4></section></summary><div class="docblock"><p>Get a <a href="adapter/struct.Urn.html"><code>Urn</code></a> formatter.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><section id="method.as_urn" class="method has-srclink"><span class="rightside"><a class="srclink" href="../src/uuid/fmt.rs.html#145-148">source</a></span><a href="#method.as_urn" class="anchor"></a><h4 class="code-header">pub fn <a href="#method.as_urn" class="fnname">as_urn</a>(&self) -> &<a class="struct" href="fmt/struct.Urn.html" title="struct uuid::fmt::Urn">Urn</a></h4></section></summary><div class="docblock"><p>Get a borrowed <a href="adapter/struct.Urn.html"><code>Urn</code></a> formatter.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><section id="method.braced" class="method has-srclink"><span class="rightside"><a class="srclink" href="../src/uuid/fmt.rs.html#155-157">source</a></span><a href="#method.braced" class="anchor"></a><h4 class="code-header">pub const fn <a href="#method.braced" class="fnname">braced</a>(self) -> <a class="struct" href="fmt/struct.Braced.html" title="struct uuid::fmt::Braced">Braced</a></h4></section></summary><div class="docblock"><p>Get a <a href="adapter/struct.Braced.html"><code>Braced</code></a> formatter.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><section id="method.as_braced" class="method has-srclink"><span class="rightside"><a class="srclink" href="../src/uuid/fmt.rs.html#164-167">source</a></span><a href="#method.as_braced" class="anchor"></a><h4 class="code-header">pub fn <a href="#method.as_braced" class="fnname">as_braced</a>(&self) -> &<a class="struct" href="fmt/struct.Braced.html" title="struct uuid::fmt::Braced">Braced</a></h4></section></summary><div class="docblock"><p>Get a borrowed <a href="adapter/struct.Braced.html"><code>Braced</code></a> formatter.</p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle" open><summary><section id="impl-3" class="impl has-srclink"><span class="rightside"><a class="srclink" href="../src/uuid/lib.rs.html#405-818">source</a></span><a href="#impl-3" class="anchor"></a><h3 class="code-header in-band">impl <a class="struct" href="struct.Uuid.html" title="struct uuid::Uuid">Uuid</a></h3></section></summary><div class="impl-items"><details class="rustdoc-toggle" open><summary><section id="associatedconstant.NAMESPACE_DNS" class="associatedconstant has-srclink"><span class="rightside"><a class="srclink" href="../src/uuid/lib.rs.html#407-410">source</a></span><a href="#associatedconstant.NAMESPACE_DNS" class="anchor"></a><h4 class="code-header">pub const <a href="#associatedconstant.NAMESPACE_DNS" class="constant">NAMESPACE_DNS</a>: Self = Uuid([
0x6b, 0xa7, 0xb8, 0x10, 0x9d, 0xad, 0x11, 0xd1, 0x80, 0xb4, 0x00, 0xc0,
0x4f, 0xd4, 0x30, 0xc8,
])</h4></section></summary><div class="docblock"><p>UUID namespace for Domain Name System (DNS).</p>
</div></details><details class="rustdoc-toggle" open><summary><section id="associatedconstant.NAMESPACE_OID" class="associatedconstant has-srclink"><span class="rightside"><a class="srclink" href="../src/uuid/lib.rs.html#413-416">source</a></span><a href="#associatedconstant.NAMESPACE_OID" class="anchor"></a><h4 class="code-header">pub const <a href="#associatedconstant.NAMESPACE_OID" class="constant">NAMESPACE_OID</a>: Self = Uuid([
0x6b, 0xa7, 0xb8, 0x12, 0x9d, 0xad, 0x11, 0xd1, 0x80, 0xb4, 0x00, 0xc0,
0x4f, 0xd4, 0x30, 0xc8,
])</h4></section></summary><div class="docblock"><p>UUID namespace for ISO Object Identifiers (OIDs).</p>
</div></details><details class="rustdoc-toggle" open><summary><section id="associatedconstant.NAMESPACE_URL" class="associatedconstant has-srclink"><span class="rightside"><a class="srclink" href="../src/uuid/lib.rs.html#419-422">source</a></span><a href="#associatedconstant.NAMESPACE_URL" class="anchor"></a><h4 class="code-header">pub const <a href="#associatedconstant.NAMESPACE_URL" class="constant">NAMESPACE_URL</a>: Self = Uuid([
0x6b, 0xa7, 0xb8, 0x11, 0x9d, 0xad, 0x11, 0xd1, 0x80, 0xb4, 0x00, 0xc0,
0x4f, 0xd4, 0x30, 0xc8,
])</h4></section></summary><div class="docblock"><p>UUID namespace for Uniform Resource Locators (URLs).</p>
</div></details><details class="rustdoc-toggle" open><summary><section id="associatedconstant.NAMESPACE_X500" class="associatedconstant has-srclink"><span class="rightside"><a class="srclink" href="../src/uuid/lib.rs.html#425-428">source</a></span><a href="#associatedconstant.NAMESPACE_X500" class="anchor"></a><h4 class="code-header">pub const <a href="#associatedconstant.NAMESPACE_X500" class="constant">NAMESPACE_X500</a>: Self = Uuid([
0x6b, 0xa7, 0xb8, 0x14, 0x9d, 0xad, 0x11, 0xd1, 0x80, 0xb4, 0x00, 0xc0,
0x4f, 0xd4, 0x30, 0xc8,
])</h4></section></summary><div class="docblock"><p>UUID namespace for X.500 Distinguished Names (DNs).</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><section id="method.get_variant" class="method has-srclink"><span class="rightside"><a class="srclink" href="../src/uuid/lib.rs.html#453-464">source</a></span><a href="#method.get_variant" class="anchor"></a><h4 class="code-header">pub const fn <a href="#method.get_variant" class="fnname">get_variant</a>(&self) -> <a class="enum" href="enum.Variant.html" title="enum uuid::Variant">Variant</a></h4></section></summary><div class="docblock"><p>Returns the variant of the UUID structure.</p>
<p>This determines the interpretation of the structure of the UUID.
This method simply reads the value of the variant byte. It doesn’t
validate the rest of the UUID as conforming to that variant.</p>
<h5 id="examples-15"><a href="#examples-15">Examples</a></h5>
<p>Basic usage:</p>
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">let</span> <span class="ident">my_uuid</span> <span class="op">=</span> <span class="ident">Uuid::parse_str</span>(<span class="string">"02f09a3f-1624-3b1d-8409-44eff7708208"</span>)<span class="question-mark">?</span>;
<span class="macro">assert_eq!</span>(<span class="ident">Variant::RFC4122</span>, <span class="ident">my_uuid</span>.<span class="ident">get_variant</span>());</code></pre></div>
<h5 id="references"><a href="#references">References</a></h5>
<ul>
<li><a href="http://tools.ietf.org/html/rfc4122#section-4.1.1">Variant in RFC4122</a></li>
</ul>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><section id="method.get_version_num" class="method has-srclink"><span class="rightside"><a class="srclink" href="../src/uuid/lib.rs.html#488-490">source</a></span><a href="#method.get_version_num" class="anchor"></a><h4 class="code-header">pub const fn <a href="#method.get_version_num" class="fnname">get_version_num</a>(&self) -> <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.usize.html">usize</a></h4></section></summary><div class="docblock"><p>Returns the version number of the UUID.</p>
<p>This represents the algorithm used to generate the value.
This method is the future-proof alternative to <a href="struct.Uuid.html#method.get_version" title="Uuid::get_version"><code>Uuid::get_version</code></a>.</p>
<h5 id="examples-16"><a href="#examples-16">Examples</a></h5>
<p>Basic usage:</p>
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">let</span> <span class="ident">my_uuid</span> <span class="op">=</span> <span class="ident">Uuid::parse_str</span>(<span class="string">"02f09a3f-1624-3b1d-8409-44eff7708208"</span>)<span class="question-mark">?</span>;
<span class="macro">assert_eq!</span>(<span class="number">3</span>, <span class="ident">my_uuid</span>.<span class="ident">get_version_num</span>());</code></pre></div>
<h5 id="references-1"><a href="#references-1">References</a></h5>
<ul>
<li><a href="https://datatracker.ietf.org/doc/html/rfc4122#section-4.1.3">Version in RFC4122</a></li>
</ul>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><section id="method.get_version" class="method has-srclink"><span class="rightside"><a class="srclink" href="../src/uuid/lib.rs.html#518-528">source</a></span><a href="#method.get_version" class="anchor"></a><h4 class="code-header">pub const fn <a href="#method.get_version" class="fnname">get_version</a>(&self) -> <a class="enum" href="https://doc.rust-lang.org/nightly/core/option/enum.Option.html" title="enum core::option::Option">Option</a><<a class="enum" href="enum.Version.html" title="enum uuid::Version">Version</a>></h4></section></summary><div class="docblock"><p>Returns the version of the UUID.</p>
<p>This represents the algorithm used to generate the value.
If the version field doesn’t contain a recognized version then <code>None</code>
is returned. If you’re trying to read the version for a future extension
you can also use <a href="struct.Uuid.html#method.get_version_num" title="Uuid::get_version_num"><code>Uuid::get_version_num</code></a> to unconditionally return a
number. Future extensions may start to return <code>Some</code> once they’re
standardized and supported.</p>
<h5 id="examples-17"><a href="#examples-17">Examples</a></h5>
<p>Basic usage:</p>
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">let</span> <span class="ident">my_uuid</span> <span class="op">=</span> <span class="ident">Uuid::parse_str</span>(<span class="string">"02f09a3f-1624-3b1d-8409-44eff7708208"</span>)<span class="question-mark">?</span>;
<span class="macro">assert_eq!</span>(<span class="prelude-val">Some</span>(<span class="ident">Version::Md5</span>), <span class="ident">my_uuid</span>.<span class="ident">get_version</span>());</code></pre></div>
<h5 id="references-2"><a href="#references-2">References</a></h5>
<ul>
<li><a href="https://datatracker.ietf.org/doc/html/rfc4122#section-4.1.3">Version in RFC4122</a></li>
</ul>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><section id="method.as_fields" class="method has-srclink"><span class="rightside"><a class="srclink" href="../src/uuid/lib.rs.html#573-587">source</a></span><a href="#method.as_fields" class="anchor"></a><h4 class="code-header">pub fn <a href="#method.as_fields" class="fnname">as_fields</a>(&self) -> <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.tuple.html">(</a><a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.u32.html">u32</a>, <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.u16.html">u16</a>, <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.u16.html">u16</a>, &<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.array.html">[</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.array.html">; 8]</a><a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.tuple.html">)</a></h4></section></summary><div class="docblock"><p>Returns the four field values of the UUID.</p>
<p>These values can be passed to the <a href="struct.Uuid.html#method.from_fields" title="Uuid::from_fields"><code>Uuid::from_fields</code></a> method to get
the original <code>Uuid</code> back.</p>
<ul>
<li>The first field value represents the first group of (eight) hex
digits, taken as a big-endian <code>u32</code> value. For V1 UUIDs, this field
represents the low 32 bits of the timestamp.</li>
<li>The second field value represents the second group of (four) hex
digits, taken as a big-endian <code>u16</code> value. For V1 UUIDs, this field
represents the middle 16 bits of the timestamp.</li>
<li>The third field value represents the third group of (four) hex digits,
taken as a big-endian <code>u16</code> value. The 4 most significant bits give
the UUID version, and for V1 UUIDs, the last 12 bits represent the
high 12 bits of the timestamp.</li>
<li>The last field value represents the last two groups of four and twelve
hex digits, taken in order. The first 1-3 bits of this indicate the
UUID variant, and for V1 UUIDs, the next 13-15 bits indicate the clock
sequence and the last 48 bits indicate the node ID.</li>
</ul>
<h5 id="examples-18"><a href="#examples-18">Examples</a></h5>
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">let</span> <span class="ident">uuid</span> <span class="op">=</span> <span class="ident">Uuid::nil</span>();
<span class="macro">assert_eq!</span>(<span class="ident">uuid</span>.<span class="ident">as_fields</span>(), (<span class="number">0</span>, <span class="number">0</span>, <span class="number">0</span>, <span class="kw-2">&</span>[<span class="number">0u8</span>; <span class="number">8</span>]));
<span class="kw">let</span> <span class="ident">uuid</span> <span class="op">=</span> <span class="ident">Uuid::parse_str</span>(<span class="string">"a1a2a3a4-b1b2-c1c2-d1d2-d3d4d5d6d7d8"</span>)<span class="question-mark">?</span>;
<span class="macro">assert_eq!</span>(
<span class="ident">uuid</span>.<span class="ident">as_fields</span>(),
(
<span class="number">0xa1a2a3a4</span>,
<span class="number">0xb1b2</span>,
<span class="number">0xc1c2</span>,
<span class="kw-2">&</span>[<span class="number">0xd1</span>, <span class="number">0xd2</span>, <span class="number">0xd3</span>, <span class="number">0xd4</span>, <span class="number">0xd5</span>, <span class="number">0xd6</span>, <span class="number">0xd7</span>, <span class="number">0xd8</span>],
)
);</code></pre></div>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><section id="method.to_fields_le" class="method has-srclink"><span class="rightside"><a class="srclink" href="../src/uuid/lib.rs.html#616-629">source</a></span><a href="#method.to_fields_le" class="anchor"></a><h4 class="code-header">pub fn <a href="#method.to_fields_le" class="fnname">to_fields_le</a>(&self) -> <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.tuple.html">(</a><a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.u32.html">u32</a>, <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.u16.html">u16</a>, <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.u16.html">u16</a>, &<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.array.html">[</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.array.html">; 8]</a><a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.tuple.html">)</a></h4></section></summary><div class="docblock"><p>Returns the four field values of the UUID in little-endian order.</p>
<p>The bytes in the returned integer fields will be converted from
big-endian order. This is based on the endianness of the UUID,
rather than the target environment so bytes will be flipped on both
big and little endian machines.</p>
<h5 id="examples-19"><a href="#examples-19">Examples</a></h5>
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use</span> <span class="ident">uuid::Uuid</span>;
<span class="kw">let</span> <span class="ident">uuid</span> <span class="op">=</span> <span class="ident">Uuid::parse_str</span>(<span class="string">"a1a2a3a4-b1b2-c1c2-d1d2-d3d4d5d6d7d8"</span>)<span class="question-mark">?</span>;
<span class="macro">assert_eq!</span>(
<span class="ident">uuid</span>.<span class="ident">to_fields_le</span>(),
(
<span class="number">0xa4a3a2a1</span>,
<span class="number">0xb2b1</span>,
<span class="number">0xc2c1</span>,
<span class="kw-2">&</span>[<span class="number">0xd1</span>, <span class="number">0xd2</span>, <span class="number">0xd3</span>, <span class="number">0xd4</span>, <span class="number">0xd5</span>, <span class="number">0xd6</span>, <span class="number">0xd7</span>, <span class="number">0xd8</span>],
)
);</code></pre></div>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><section id="method.as_u128" class="method has-srclink"><span class="rightside"><a class="srclink" href="../src/uuid/lib.rs.html#649-666">source</a></span><a href="#method.as_u128" class="anchor"></a><h4 class="code-header">pub const fn <a href="#method.as_u128" class="fnname">as_u128</a>(&self) -> <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.u128.html">u128</a></h4></section></summary><div class="docblock"><p>Returns a 128bit value containing the value.</p>
<p>The bytes in the UUID will be packed directly into a <code>u128</code>.</p>
<h5 id="examples-20"><a href="#examples-20">Examples</a></h5>
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">let</span> <span class="ident">uuid</span> <span class="op">=</span> <span class="ident">Uuid::parse_str</span>(<span class="string">"a1a2a3a4-b1b2-c1c2-d1d2-d3d4d5d6d7d8"</span>)<span class="question-mark">?</span>;
<span class="macro">assert_eq!</span>(
<span class="ident">uuid</span>.<span class="ident">as_u128</span>(),
<span class="number">0xa1a2a3a4b1b2c1c2d1d2d3d4d5d6d7d8</span>,
);</code></pre></div>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><section id="method.to_u128_le" class="method has-srclink"><span class="rightside"><a class="srclink" href="../src/uuid/lib.rs.html#693-710">source</a></span><a href="#method.to_u128_le" class="anchor"></a><h4 class="code-header">pub const fn <a href="#method.to_u128_le" class="fnname">to_u128_le</a>(&self) -> <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.u128.html">u128</a></h4></section></summary><div class="docblock"><p>Returns a 128bit little-endian value containing the value.</p>
<p>The bytes in the <code>u128</code> will be flipped to convert into big-endian
order. This is based on the endianness of the UUID, rather than the
target environment so bytes will be flipped on both big and little
endian machines.</p>
<p>Note that this will produce a different result than
<a href="struct.Uuid.html#method.to_fields_le" title="Uuid::to_fields_le"><code>Uuid::to_fields_le</code></a>, because the entire UUID is reversed, rather
than reversing the individual fields in-place.</p>
<h5 id="examples-21"><a href="#examples-21">Examples</a></h5>
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">let</span> <span class="ident">uuid</span> <span class="op">=</span> <span class="ident">Uuid::parse_str</span>(<span class="string">"a1a2a3a4-b1b2-c1c2-d1d2-d3d4d5d6d7d8"</span>)<span class="question-mark">?</span>;
<span class="macro">assert_eq!</span>(
<span class="ident">uuid</span>.<span class="ident">to_u128_le</span>(),
<span class="number">0xd8d7d6d5d4d3d2d1c2c1b2b1a4a3a2a1</span>,
);</code></pre></div>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><section id="method.as_u64_pair" class="method has-srclink"><span class="rightside"><a class="srclink" href="../src/uuid/lib.rs.html#731-734">source</a></span><a href="#method.as_u64_pair" class="anchor"></a><h4 class="code-header">pub const fn <a href="#method.as_u64_pair" class="fnname">as_u64_pair</a>(&self) -> <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.tuple.html">(</a><a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.u64.html">u64</a>, <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.u64.html">u64</a><a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.tuple.html">)</a></h4></section></summary><div class="docblock"><p>Returns two 64bit values containing the value.</p>
<p>The bytes in the UUID will be split into two <code>u64</code>.
The first u64 represents the 64 most significant bits,
the second one represents the 64 least significant.</p>
<h5 id="examples-22"><a href="#examples-22">Examples</a></h5>
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">let</span> <span class="ident">uuid</span> <span class="op">=</span> <span class="ident">Uuid::parse_str</span>(<span class="string">"a1a2a3a4-b1b2-c1c2-d1d2-d3d4d5d6d7d8"</span>)<span class="question-mark">?</span>;
<span class="macro">assert_eq!</span>(
<span class="ident">uuid</span>.<span class="ident">as_u64_pair</span>(),
(<span class="number">0xa1a2a3a4b1b2c1c2</span>, <span class="number">0xd1d2d3d4d5d6d7d8</span>),
);</code></pre></div>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><section id="method.as_bytes" class="method has-srclink"><span class="rightside"><a class="srclink" href="../src/uuid/lib.rs.html#762-764">source</a></span><a href="#method.as_bytes" class="anchor"></a><h4 class="code-header">pub const fn <a href="#method.as_bytes" class="fnname">as_bytes</a>(&self) -> &<a class="type" href="type.Bytes.html" title="type uuid::Bytes">Bytes</a></h4></section></summary><div class="docblock"><p>Returns a slice of 16 octets containing the value.</p>
<p>This method borrows the underlying byte value of the UUID.</p>
<h5 id="examples-23"><a href="#examples-23">Examples</a></h5>
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">let</span> <span class="ident">bytes1</span> <span class="op">=</span> [
<span class="number">0xa1</span>, <span class="number">0xa2</span>, <span class="number">0xa3</span>, <span class="number">0xa4</span>,
<span class="number">0xb1</span>, <span class="number">0xb2</span>,
<span class="number">0xc1</span>, <span class="number">0xc2</span>,
<span class="number">0xd1</span>, <span class="number">0xd2</span>, <span class="number">0xd3</span>, <span class="number">0xd4</span>, <span class="number">0xd5</span>, <span class="number">0xd6</span>, <span class="number">0xd7</span>, <span class="number">0xd8</span>,
];
<span class="kw">let</span> <span class="ident">uuid1</span> <span class="op">=</span> <span class="ident">Uuid::from_bytes_ref</span>(<span class="kw-2">&</span><span class="ident">bytes1</span>);
<span class="kw">let</span> <span class="ident">bytes2</span> <span class="op">=</span> <span class="ident">uuid1</span>.<span class="ident">as_bytes</span>();
<span class="kw">let</span> <span class="ident">uuid2</span> <span class="op">=</span> <span class="ident">Uuid::from_bytes_ref</span>(<span class="ident">bytes2</span>);
<span class="macro">assert_eq!</span>(<span class="ident">uuid1</span>, <span class="ident">uuid2</span>);
<span class="macro">assert!</span>(<span class="ident">std::ptr::eq</span>(
<span class="ident">uuid2</span> <span class="kw">as</span> <span class="kw-2">*const</span> <span class="ident">Uuid</span> <span class="kw">as</span> <span class="kw-2">*const</span> <span class="ident">u8</span>,
<span class="kw-2">&</span><span class="ident">bytes1</span> <span class="kw">as</span> <span class="kw-2">*const</span> [<span class="ident">u8</span>; <span class="number">16</span>] <span class="kw">as</span> <span class="kw-2">*const</span> <span class="ident">u8</span>,
));</code></pre></div>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><section id="method.into_bytes" class="method has-srclink"><span class="rightside"><a class="srclink" href="../src/uuid/lib.rs.html#781-783">source</a></span><a href="#method.into_bytes" class="anchor"></a><h4 class="code-header">pub const fn <a href="#method.into_bytes" class="fnname">into_bytes</a>(self) -> <a class="type" href="type.Bytes.html" title="type uuid::Bytes">Bytes</a></h4></section></summary><div class="docblock"><p>Consumes self and returns the underlying byte value of the UUID.</p>
<h5 id="examples-24"><a href="#examples-24">Examples</a></h5>
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">let</span> <span class="ident">bytes</span> <span class="op">=</span> [
<span class="number">0xa1</span>, <span class="number">0xa2</span>, <span class="number">0xa3</span>, <span class="number">0xa4</span>,
<span class="number">0xb1</span>, <span class="number">0xb2</span>,
<span class="number">0xc1</span>, <span class="number">0xc2</span>,
<span class="number">0xd1</span>, <span class="number">0xd2</span>, <span class="number">0xd3</span>, <span class="number">0xd4</span>, <span class="number">0xd5</span>, <span class="number">0xd6</span>, <span class="number">0xd7</span>, <span class="number">0xd8</span>,
];
<span class="kw">let</span> <span class="ident">uuid</span> <span class="op">=</span> <span class="ident">Uuid::from_bytes</span>(<span class="ident">bytes</span>);
<span class="macro">assert_eq!</span>(<span class="ident">bytes</span>, <span class="ident">uuid</span>.<span class="ident">into_bytes</span>());</code></pre></div>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><section id="method.is_nil" class="method has-srclink"><span class="rightside"><a class="srclink" href="../src/uuid/lib.rs.html#786-788">source</a></span><a href="#method.is_nil" class="anchor"></a><h4 class="code-header">pub const fn <a href="#method.is_nil" class="fnname">is_nil</a>(&self) -> <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.bool.html">bool</a></h4></section></summary><div class="docblock"><p>Tests if the UUID is nil.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><section id="method.encode_buffer" class="method has-srclink"><span class="rightside"><a class="srclink" href="../src/uuid/lib.rs.html#815-817">source</a></span><a href="#method.encode_buffer" class="anchor"></a><h4 class="code-header">pub const fn <a href="#method.encode_buffer" class="fnname">encode_buffer</a>() -> <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.array.html">[</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.array.html">; 45]</a></h4></section></summary><div class="docblock"><p>A buffer that can be used for <code>encode_...</code> calls, that is
guaranteed to be long enough for any of the format adapters.</p>
<h5 id="examples-25"><a href="#examples-25">Examples</a></h5>
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">let</span> <span class="ident">uuid</span> <span class="op">=</span> <span class="ident">Uuid::nil</span>();
<span class="macro">assert_eq!</span>(
<span class="ident">uuid</span>.<span class="ident">simple</span>().<span class="ident">encode_lower</span>(<span class="kw-2">&mut</span> <span class="ident">Uuid::encode_buffer</span>()),
<span class="string">"00000000000000000000000000000000"</span>
);
<span class="macro">assert_eq!</span>(
<span class="ident">uuid</span>.<span class="ident">hyphenated</span>()
.<span class="ident">encode_lower</span>(<span class="kw-2">&mut</span> <span class="ident">Uuid::encode_buffer</span>()),
<span class="string">"00000000-0000-0000-0000-000000000000"</span>
);
<span class="macro">assert_eq!</span>(
<span class="ident">uuid</span>.<span class="ident">urn</span>().<span class="ident">encode_lower</span>(<span class="kw-2">&mut</span> <span class="ident">Uuid::encode_buffer</span>()),
<span class="string">"urn:uuid:00000000-0000-0000-0000-000000000000"</span>
);</code></pre></div>
</div></details></div></details></div><h2 id="trait-implementations" class="small-section-header">Trait Implementations<a href="#trait-implementations" class="anchor"></a></h2><div id="trait-implementations-list"><details class="rustdoc-toggle implementors-toggle" open><summary><section id="impl-AsRef%3C%5Bu8%5D%3E" class="impl has-srclink"><span class="rightside"><a class="srclink" href="../src/uuid/lib.rs.html#827-832">source</a></span><a href="#impl-AsRef%3C%5Bu8%5D%3E" class="anchor"></a><h3 class="code-header in-band">impl <a class="trait" href="https://doc.rust-lang.org/nightly/core/convert/trait.AsRef.html" title="trait core::convert::AsRef">AsRef</a><<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.slice.html">[</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>> for <a class="struct" href="struct.Uuid.html" title="struct uuid::Uuid">Uuid</a></h3></section></summary><div class="impl-items"><details class="rustdoc-toggle method-toggle" open><summary><section id="method.as_ref-4" class="method trait-impl has-srclink"><span class="rightside"><a class="srclink" href="../src/uuid/lib.rs.html#829-831">source</a></span><a href="#method.as_ref-4" class="anchor"></a><h4 class="code-header">fn <a href="https://doc.rust-lang.org/nightly/core/convert/trait.AsRef.html#tymethod.as_ref" class="fnname">as_ref</a>(&self) -> <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.slice.html">&[</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><span class="notable-traits"><span class="notable-traits-tooltip">ⓘ<span class="notable-traits-tooltiptext"><span class="docblock"><span class="notable">Notable traits for <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.slice.html">&'_ [</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></span><code class="content"><span class="where fmt-newline">impl<'_> <a class="trait" href="https://doc.rust-lang.org/nightly/std/io/trait.Read.html" title="trait std::io::Read">Read</a> for <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.slice.html">&'_ [</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></span><span class="where fmt-newline">impl<'_> <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="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.slice.html">&'_ 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></span></code></span></span></span></span></h4></section></summary><div class='docblock'><p>Converts this type into a shared reference of the (usually inferred) input type.</p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle" open><summary><section id="impl-AsRef%3CUuid%3E" class="impl has-srclink"><span class="rightside"><a class="srclink" href="../src/uuid/fmt.rs.html#962-967">source</a></span><a href="#impl-AsRef%3CUuid%3E" class="anchor"></a><h3 class="code-header in-band">impl <a class="trait" href="https://doc.rust-lang.org/nightly/core/convert/trait.AsRef.html" title="trait core::convert::AsRef">AsRef</a><<a class="struct" href="struct.Uuid.html" title="struct uuid::Uuid">Uuid</a>> for <a class="struct" href="fmt/struct.Hyphenated.html" title="struct uuid::fmt::Hyphenated">Hyphenated</a></h3></section></summary><div class="impl-items"><details class="rustdoc-toggle method-toggle" open><summary><section id="method.as_ref" class="method trait-impl has-srclink"><span class="rightside"><a class="srclink" href="../src/uuid/fmt.rs.html#962-967">source</a></span><a href="#method.as_ref" class="anchor"></a><h4 class="code-header">fn <a href="https://doc.rust-lang.org/nightly/core/convert/trait.AsRef.html#tymethod.as_ref" class="fnname">as_ref</a>(&self) -> &<a class="struct" href="struct.Uuid.html" title="struct uuid::Uuid">Uuid</a></h4></section></summary><div class='docblock'><p>Converts this type into a shared reference of the (usually inferred) input type.</p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle" open><summary><section id="impl-AsRef%3CUuid%3E-1" class="impl has-srclink"><span class="rightside"><a class="srclink" href="../src/uuid/fmt.rs.html#962-967">source</a></span><a href="#impl-AsRef%3CUuid%3E-1" class="anchor"></a><h3 class="code-header in-band">impl <a class="trait" href="https://doc.rust-lang.org/nightly/core/convert/trait.AsRef.html" title="trait core::convert::AsRef">AsRef</a><<a class="struct" href="struct.Uuid.html" title="struct uuid::Uuid">Uuid</a>> for <a class="struct" href="fmt/struct.Simple.html" title="struct uuid::fmt::Simple">Simple</a></h3></section></summary><div class="impl-items"><details class="rustdoc-toggle method-toggle" open><summary><section id="method.as_ref-1" class="method trait-impl has-srclink"><span class="rightside"><a class="srclink" href="../src/uuid/fmt.rs.html#962-967">source</a></span><a href="#method.as_ref-1" class="anchor"></a><h4 class="code-header">fn <a href="https://doc.rust-lang.org/nightly/core/convert/trait.AsRef.html#tymethod.as_ref" class="fnname">as_ref</a>(&self) -> &<a class="struct" href="struct.Uuid.html" title="struct uuid::Uuid">Uuid</a></h4></section></summary><div class='docblock'><p>Converts this type into a shared reference of the (usually inferred) input type.</p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle" open><summary><section id="impl-AsRef%3CUuid%3E-2" class="impl has-srclink"><span class="rightside"><a class="srclink" href="../src/uuid/fmt.rs.html#962-967">source</a></span><a href="#impl-AsRef%3CUuid%3E-2" class="anchor"></a><h3 class="code-header in-band">impl <a class="trait" href="https://doc.rust-lang.org/nightly/core/convert/trait.AsRef.html" title="trait core::convert::AsRef">AsRef</a><<a class="struct" href="struct.Uuid.html" title="struct uuid::Uuid">Uuid</a>> for <a class="struct" href="fmt/struct.Urn.html" title="struct uuid::fmt::Urn">Urn</a></h3></section></summary><div class="impl-items"><details class="rustdoc-toggle method-toggle" open><summary><section id="method.as_ref-2" class="method trait-impl has-srclink"><span class="rightside"><a class="srclink" href="../src/uuid/fmt.rs.html#962-967">source</a></span><a href="#method.as_ref-2" class="anchor"></a><h4 class="code-header">fn <a href="https://doc.rust-lang.org/nightly/core/convert/trait.AsRef.html#tymethod.as_ref" class="fnname">as_ref</a>(&self) -> &<a class="struct" href="struct.Uuid.html" title="struct uuid::Uuid">Uuid</a></h4></section></summary><div class='docblock'><p>Converts this type into a shared reference of the (usually inferred) input type.</p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle" open><summary><section id="impl-AsRef%3CUuid%3E-3" class="impl has-srclink"><span class="rightside"><a class="srclink" href="../src/uuid/fmt.rs.html#962-967">source</a></span><a href="#impl-AsRef%3CUuid%3E-3" class="anchor"></a><h3 class="code-header in-band">impl <a class="trait" href="https://doc.rust-lang.org/nightly/core/convert/trait.AsRef.html" title="trait core::convert::AsRef">AsRef</a><<a class="struct" href="struct.Uuid.html" title="struct uuid::Uuid">Uuid</a>> for <a class="struct" href="fmt/struct.Braced.html" title="struct uuid::fmt::Braced">Braced</a></h3></section></summary><div class="impl-items"><details class="rustdoc-toggle method-toggle" open><summary><section id="method.as_ref-3" class="method trait-impl has-srclink"><span class="rightside"><a class="srclink" href="../src/uuid/fmt.rs.html#962-967">source</a></span><a href="#method.as_ref-3" class="anchor"></a><h4 class="code-header">fn <a href="https://doc.rust-lang.org/nightly/core/convert/trait.AsRef.html#tymethod.as_ref" class="fnname">as_ref</a>(&self) -> &<a class="struct" href="struct.Uuid.html" title="struct uuid::Uuid">Uuid</a></h4></section></summary><div class='docblock'><p>Converts this type into a shared reference of the (usually inferred) input type.</p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle" open><summary><section id="impl-Borrow%3CUuid%3E" class="impl has-srclink"><span class="rightside"><a class="srclink" href="../src/uuid/fmt.rs.html#962-967">source</a></span><a href="#impl-Borrow%3CUuid%3E" class="anchor"></a><h3 class="code-header in-band">impl <a class="trait" href="https://doc.rust-lang.org/nightly/core/borrow/trait.Borrow.html" title="trait core::borrow::Borrow">Borrow</a><<a class="struct" href="struct.Uuid.html" title="struct uuid::Uuid">Uuid</a>> for <a class="struct" href="fmt/struct.Hyphenated.html" title="struct uuid::fmt::Hyphenated">Hyphenated</a></h3></section></summary><div class="impl-items"><details class="rustdoc-toggle method-toggle" open><summary><section id="method.borrow" class="method trait-impl has-srclink"><span class="rightside"><a class="srclink" href="../src/uuid/fmt.rs.html#962-967">source</a></span><a href="#method.borrow" class="anchor"></a><h4 class="code-header">fn <a href="https://doc.rust-lang.org/nightly/core/borrow/trait.Borrow.html#tymethod.borrow" class="fnname">borrow</a>(&self) -> &<a class="struct" href="struct.Uuid.html" title="struct uuid::Uuid">Uuid</a></h4></section></summary><div class='docblock'><p>Immutably borrows from an owned value. <a href="https://doc.rust-lang.org/nightly/core/borrow/trait.Borrow.html#tymethod.borrow">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle" open><summary><section id="impl-Borrow%3CUuid%3E-1" class="impl has-srclink"><span class="rightside"><a class="srclink" href="../src/uuid/fmt.rs.html#962-967">source</a></span><a href="#impl-Borrow%3CUuid%3E-1" class="anchor"></a><h3 class="code-header in-band">impl <a class="trait" href="https://doc.rust-lang.org/nightly/core/borrow/trait.Borrow.html" title="trait core::borrow::Borrow">Borrow</a><<a class="struct" href="struct.Uuid.html" title="struct uuid::Uuid">Uuid</a>> for <a class="struct" href="fmt/struct.Simple.html" title="struct uuid::fmt::Simple">Simple</a></h3></section></summary><div class="impl-items"><details class="rustdoc-toggle method-toggle" open><summary><section id="method.borrow-1" class="method trait-impl has-srclink"><span class="rightside"><a class="srclink" href="../src/uuid/fmt.rs.html#962-967">source</a></span><a href="#method.borrow-1" class="anchor"></a><h4 class="code-header">fn <a href="https://doc.rust-lang.org/nightly/core/borrow/trait.Borrow.html#tymethod.borrow" class="fnname">borrow</a>(&self) -> &<a class="struct" href="struct.Uuid.html" title="struct uuid::Uuid">Uuid</a></h4></section></summary><div class='docblock'><p>Immutably borrows from an owned value. <a href="https://doc.rust-lang.org/nightly/core/borrow/trait.Borrow.html#tymethod.borrow">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle" open><summary><section id="impl-Borrow%3CUuid%3E-2" class="impl has-srclink"><span class="rightside"><a class="srclink" href="../src/uuid/fmt.rs.html#962-967">source</a></span><a href="#impl-Borrow%3CUuid%3E-2" class="anchor"></a><h3 class="code-header in-band">impl <a class="trait" href="https://doc.rust-lang.org/nightly/core/borrow/trait.Borrow.html" title="trait core::borrow::Borrow">Borrow</a><<a class="struct" href="struct.Uuid.html" title="struct uuid::Uuid">Uuid</a>> for <a class="struct" href="fmt/struct.Urn.html" title="struct uuid::fmt::Urn">Urn</a></h3></section></summary><div class="impl-items"><details class="rustdoc-toggle method-toggle" open><summary><section id="method.borrow-2" class="method trait-impl has-srclink"><span class="rightside"><a class="srclink" href="../src/uuid/fmt.rs.html#962-967">source</a></span><a href="#method.borrow-2" class="anchor"></a><h4 class="code-header">fn <a href="https://doc.rust-lang.org/nightly/core/borrow/trait.Borrow.html#tymethod.borrow" class="fnname">borrow</a>(&self) -> &<a class="struct" href="struct.Uuid.html" title="struct uuid::Uuid">Uuid</a></h4></section></summary><div class='docblock'><p>Immutably borrows from an owned value. <a href="https://doc.rust-lang.org/nightly/core/borrow/trait.Borrow.html#tymethod.borrow">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle" open><summary><section id="impl-Borrow%3CUuid%3E-3" class="impl has-srclink"><span class="rightside"><a class="srclink" href="../src/uuid/fmt.rs.html#962-967">source</a></span><a href="#impl-Borrow%3CUuid%3E-3" class="anchor"></a><h3 class="code-header in-band">impl <a class="trait" href="https://doc.rust-lang.org/nightly/core/borrow/trait.Borrow.html" title="trait core::borrow::Borrow">Borrow</a><<a class="struct" href="struct.Uuid.html" title="struct uuid::Uuid">Uuid</a>> for <a class="struct" href="fmt/struct.Braced.html" title="struct uuid::fmt::Braced">Braced</a></h3></section></summary><div class="impl-items"><details class="rustdoc-toggle method-toggle" open><summary><section id="method.borrow-3" class="method trait-impl has-srclink"><span class="rightside"><a class="srclink" href="../src/uuid/fmt.rs.html#962-967">source</a></span><a href="#method.borrow-3" class="anchor"></a><h4 class="code-header">fn <a href="https://doc.rust-lang.org/nightly/core/borrow/trait.Borrow.html#tymethod.borrow" class="fnname">borrow</a>(&self) -> &<a class="struct" href="struct.Uuid.html" title="struct uuid::Uuid">Uuid</a></h4></section></summary><div class='docblock'><p>Immutably borrows from an owned value. <a href="https://doc.rust-lang.org/nightly/core/borrow/trait.Borrow.html#tymethod.borrow">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle" open><summary><section id="impl-Clone" class="impl has-srclink"><span class="rightside"><a class="srclink" href="../src/uuid/lib.rs.html#397">source</a></span><a href="#impl-Clone" class="anchor"></a><h3 class="code-header in-band">impl <a class="trait" href="https://doc.rust-lang.org/nightly/core/clone/trait.Clone.html" title="trait core::clone::Clone">Clone</a> for <a class="struct" href="struct.Uuid.html" title="struct uuid::Uuid">Uuid</a></h3></section></summary><div class="impl-items"><details class="rustdoc-toggle method-toggle" open><summary><section id="method.clone" class="method trait-impl has-srclink"><span class="rightside"><a class="srclink" href="../src/uuid/lib.rs.html#397">source</a></span><a href="#method.clone" class="anchor"></a><h4 class="code-header">fn <a href="https://doc.rust-lang.org/nightly/core/clone/trait.Clone.html#tymethod.clone" class="fnname">clone</a>(&self) -> <a class="struct" href="struct.Uuid.html" title="struct uuid::Uuid">Uuid</a></h4></section></summary><div class='docblock'><p>Returns a copy of the value. <a href="https://doc.rust-lang.org/nightly/core/clone/trait.Clone.html#tymethod.clone">Read more</a></p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><section id="method.clone_from" class="method trait-impl has-srclink"><span class="rightside"><span class="since" title="Stable since Rust version 1.0.0">1.0.0</span> · <a class="srclink" href="https://doc.rust-lang.org/nightly/src/core/clone.rs.html#133-135">source</a></span><a href="#method.clone_from" class="anchor"></a><h4 class="code-header">fn <a href="https://doc.rust-lang.org/nightly/core/clone/trait.Clone.html#method.clone_from" class="fnname">clone_from</a>(&mut self, source: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.reference.html">&</a>Self)</h4></section></summary><div class='docblock'><p>Performs copy-assignment from <code>source</code>. <a href="https://doc.rust-lang.org/nightly/core/clone/trait.Clone.html#method.clone_from">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle" open><summary><section id="impl-Debug" class="impl has-srclink"><span class="rightside"><a class="srclink" href="../src/uuid/fmt.rs.html#19-24">source</a></span><a href="#impl-Debug" class="anchor"></a><h3 class="code-header in-band">impl <a class="trait" href="https://doc.rust-lang.org/nightly/core/fmt/trait.Debug.html" title="trait core::fmt::Debug">Debug</a> for <a class="struct" href="struct.Uuid.html" title="struct uuid::Uuid">Uuid</a></h3></section></summary><div class="impl-items"><details class="rustdoc-toggle method-toggle" open><summary><section id="method.fmt" class="method trait-impl has-srclink"><span class="rightside"><a class="srclink" href="../src/uuid/fmt.rs.html#21-23">source</a></span><a href="#method.fmt" class="anchor"></a><h4 class="code-header">fn <a href="https://doc.rust-lang.org/nightly/core/fmt/trait.Debug.html#tymethod.fmt" class="fnname">fmt</a>(&self, f: &mut <a class="struct" href="https://doc.rust-lang.org/nightly/core/fmt/struct.Formatter.html" title="struct core::fmt::Formatter">Formatter</a><'_>) -> <a class="type" href="https://doc.rust-lang.org/nightly/core/fmt/type.Result.html" title="type core::fmt::Result">Result</a></h4></section></summary><div class='docblock'><p>Formats the value using the given formatter. <a href="https://doc.rust-lang.org/nightly/core/fmt/trait.Debug.html#tymethod.fmt">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle" open><summary><section id="impl-Default" class="impl has-srclink"><span class="rightside"><a class="srclink" href="../src/uuid/lib.rs.html#820-825">source</a></span><a href="#impl-Default" class="anchor"></a><h3 class="code-header in-band">impl <a class="trait" href="https://doc.rust-lang.org/nightly/core/default/trait.Default.html" title="trait core::default::Default">Default</a> for <a class="struct" href="struct.Uuid.html" title="struct uuid::Uuid">Uuid</a></h3></section></summary><div class="impl-items"><details class="rustdoc-toggle method-toggle" open><summary><section id="method.default" class="method trait-impl has-srclink"><span class="rightside"><a class="srclink" href="../src/uuid/lib.rs.html#822-824">source</a></span><a href="#method.default" class="anchor"></a><h4 class="code-header">fn <a href="https://doc.rust-lang.org/nightly/core/default/trait.Default.html#tymethod.default" class="fnname">default</a>() -> Self</h4></section></summary><div class='docblock'><p>Returns the “default value” for a type. <a href="https://doc.rust-lang.org/nightly/core/default/trait.Default.html#tymethod.default">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle" open><summary><section id="impl-Display" class="impl has-srclink"><span class="rightside"><a class="srclink" href="../src/uuid/fmt.rs.html#26-30">source</a></span><a href="#impl-Display" class="anchor"></a><h3 class="code-header in-band">impl <a class="trait" href="https://doc.rust-lang.org/nightly/core/fmt/trait.Display.html" title="trait core::fmt::Display">Display</a> for <a class="struct" href="struct.Uuid.html" title="struct uuid::Uuid">Uuid</a></h3></section></summary><div class="impl-items"><details class="rustdoc-toggle method-toggle" open><summary><section id="method.fmt-1" class="method trait-impl has-srclink"><span class="rightside"><a class="srclink" href="../src/uuid/fmt.rs.html#27-29">source</a></span><a href="#method.fmt-1" class="anchor"></a><h4 class="code-header">fn <a href="https://doc.rust-lang.org/nightly/core/fmt/trait.Display.html#tymethod.fmt" class="fnname">fmt</a>(&self, f: &mut <a class="struct" href="https://doc.rust-lang.org/nightly/core/fmt/struct.Formatter.html" title="struct core::fmt::Formatter">Formatter</a><'_>) -> <a class="type" href="https://doc.rust-lang.org/nightly/core/fmt/type.Result.html" title="type core::fmt::Result">Result</a></h4></section></summary><div class='docblock'><p>Formats the value using the given formatter. <a href="https://doc.rust-lang.org/nightly/core/fmt/trait.Display.html#tymethod.fmt">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle" open><summary><section id="impl-From%3CBraced%3E" class="impl has-srclink"><span class="rightside"><a class="srclink" href="../src/uuid/fmt.rs.html#962-967">source</a></span><a href="#impl-From%3CBraced%3E" class="anchor"></a><h3 class="code-header in-band">impl <a class="trait" href="https://doc.rust-lang.org/nightly/core/convert/trait.From.html" title="trait core::convert::From">From</a><<a class="struct" href="fmt/struct.Braced.html" title="struct uuid::fmt::Braced">Braced</a>> for <a class="struct" href="struct.Uuid.html" title="struct uuid::Uuid">Uuid</a></h3></section></summary><div class="impl-items"><details class="rustdoc-toggle method-toggle" open><summary><section id="method.from-7" class="method trait-impl has-srclink"><span class="rightside"><a class="srclink" href="../src/uuid/fmt.rs.html#962-967">source</a></span><a href="#method.from-7" class="anchor"></a><h4 class="code-header">fn <a href="https://doc.rust-lang.org/nightly/core/convert/trait.From.html#tymethod.from" class="fnname">from</a>(f: <a class="struct" href="fmt/struct.Braced.html" title="struct uuid::fmt::Braced">Braced</a>) -> Self</h4></section></summary><div class='docblock'><p>Converts to this type from the input type.</p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle" open><summary><section id="impl-From%3CHyphenated%3E" class="impl has-srclink"><span class="rightside"><a class="srclink" href="../src/uuid/fmt.rs.html#962-967">source</a></span><a href="#impl-From%3CHyphenated%3E" class="anchor"></a><h3 class="code-header in-band">impl <a class="trait" href="https://doc.rust-lang.org/nightly/core/convert/trait.From.html" title="trait core::convert::From">From</a><<a class="struct" href="fmt/struct.Hyphenated.html" title="struct uuid::fmt::Hyphenated">Hyphenated</a>> for <a class="struct" href="struct.Uuid.html" title="struct uuid::Uuid">Uuid</a></h3></section></summary><div class="impl-items"><details class="rustdoc-toggle method-toggle" open><summary><section id="method.from-1" class="method trait-impl has-srclink"><span class="rightside"><a class="srclink" href="../src/uuid/fmt.rs.html#962-967">source</a></span><a href="#method.from-1" class="anchor"></a><h4 class="code-header">fn <a href="https://doc.rust-lang.org/nightly/core/convert/trait.From.html#tymethod.from" class="fnname">from</a>(f: <a class="struct" href="fmt/struct.Hyphenated.html" title="struct uuid::fmt::Hyphenated">Hyphenated</a>) -> Self</h4></section></summary><div class='docblock'><p>Converts to this type from the input type.</p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle" open><summary><section id="impl-From%3CSimple%3E" class="impl has-srclink"><span class="rightside"><a class="srclink" href="../src/uuid/fmt.rs.html#962-967">source</a></span><a href="#impl-From%3CSimple%3E" class="anchor"></a><h3 class="code-header in-band">impl <a class="trait" href="https://doc.rust-lang.org/nightly/core/convert/trait.From.html" title="trait core::convert::From">From</a><<a class="struct" href="fmt/struct.Simple.html" title="struct uuid::fmt::Simple">Simple</a>> for <a class="struct" href="struct.Uuid.html" title="struct uuid::Uuid">Uuid</a></h3></section></summary><div class="impl-items"><details class="rustdoc-toggle method-toggle" open><summary><section id="method.from-3" class="method trait-impl has-srclink"><span class="rightside"><a class="srclink" href="../src/uuid/fmt.rs.html#962-967">source</a></span><a href="#method.from-3" class="anchor"></a><h4 class="code-header">fn <a href="https://doc.rust-lang.org/nightly/core/convert/trait.From.html#tymethod.from" class="fnname">from</a>(f: <a class="struct" href="fmt/struct.Simple.html" title="struct uuid::fmt::Simple">Simple</a>) -> Self</h4></section></summary><div class='docblock'><p>Converts to this type from the input type.</p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle" open><summary><section id="impl-From%3CUrn%3E" class="impl has-srclink"><span class="rightside"><a class="srclink" href="../src/uuid/fmt.rs.html#962-967">source</a></span><a href="#impl-From%3CUrn%3E" class="anchor"></a><h3 class="code-header in-band">impl <a class="trait" href="https://doc.rust-lang.org/nightly/core/convert/trait.From.html" title="trait core::convert::From">From</a><<a class="struct" href="fmt/struct.Urn.html" title="struct uuid::fmt::Urn">Urn</a>> for <a class="struct" href="struct.Uuid.html" title="struct uuid::Uuid">Uuid</a></h3></section></summary><div class="impl-items"><details class="rustdoc-toggle method-toggle" open><summary><section id="method.from-5" class="method trait-impl has-srclink"><span class="rightside"><a class="srclink" href="../src/uuid/fmt.rs.html#962-967">source</a></span><a href="#method.from-5" class="anchor"></a><h4 class="code-header">fn <a href="https://doc.rust-lang.org/nightly/core/convert/trait.From.html#tymethod.from" class="fnname">from</a>(f: <a class="struct" href="fmt/struct.Urn.html" title="struct uuid::fmt::Urn">Urn</a>) -> Self</h4></section></summary><div class='docblock'><p>Converts to this type from the input type.</p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle" open><summary><section id="impl-From%3CUuid%3E" class="impl has-srclink"><span class="rightside"><a class="srclink" href="../src/uuid/fmt.rs.html#962-967">source</a></span><a href="#impl-From%3CUuid%3E" class="anchor"></a><h3 class="code-header in-band">impl <a class="trait" href="https://doc.rust-lang.org/nightly/core/convert/trait.From.html" title="trait core::convert::From">From</a><<a class="struct" href="struct.Uuid.html" title="struct uuid::Uuid">Uuid</a>> for <a class="struct" href="fmt/struct.Hyphenated.html" title="struct uuid::fmt::Hyphenated">Hyphenated</a></h3></section></summary><div class="impl-items"><details class="rustdoc-toggle method-toggle" open><summary><section id="method.from" class="method trait-impl has-srclink"><span class="rightside"><a class="srclink" href="../src/uuid/fmt.rs.html#962-967">source</a></span><a href="#method.from" class="anchor"></a><h4 class="code-header">fn <a href="https://doc.rust-lang.org/nightly/core/convert/trait.From.html#tymethod.from" class="fnname">from</a>(f: <a class="struct" href="struct.Uuid.html" title="struct uuid::Uuid">Uuid</a>) -> Self</h4></section></summary><div class='docblock'><p>Converts to this type from the input type.</p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle" open><summary><section id="impl-From%3CUuid%3E-1" class="impl has-srclink"><span class="rightside"><a class="srclink" href="../src/uuid/fmt.rs.html#962-967">source</a></span><a href="#impl-From%3CUuid%3E-1" class="anchor"></a><h3 class="code-header in-band">impl <a class="trait" href="https://doc.rust-lang.org/nightly/core/convert/trait.From.html" title="trait core::convert::From">From</a><<a class="struct" href="struct.Uuid.html" title="struct uuid::Uuid">Uuid</a>> for <a class="struct" href="fmt/struct.Simple.html" title="struct uuid::fmt::Simple">Simple</a></h3></section></summary><div class="impl-items"><details class="rustdoc-toggle method-toggle" open><summary><section id="method.from-2" class="method trait-impl has-srclink"><span class="rightside"><a class="srclink" href="../src/uuid/fmt.rs.html#962-967">source</a></span><a href="#method.from-2" class="anchor"></a><h4 class="code-header">fn <a href="https://doc.rust-lang.org/nightly/core/convert/trait.From.html#tymethod.from" class="fnname">from</a>(f: <a class="struct" href="struct.Uuid.html" title="struct uuid::Uuid">Uuid</a>) -> Self</h4></section></summary><div class='docblock'><p>Converts to this type from the input type.</p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle" open><summary><section id="impl-From%3CUuid%3E-2" class="impl has-srclink"><span class="rightside"><a class="srclink" href="../src/uuid/fmt.rs.html#962-967">source</a></span><a href="#impl-From%3CUuid%3E-2" class="anchor"></a><h3 class="code-header in-band">impl <a class="trait" href="https://doc.rust-lang.org/nightly/core/convert/trait.From.html" title="trait core::convert::From">From</a><<a class="struct" href="struct.Uuid.html" title="struct uuid::Uuid">Uuid</a>> for <a class="struct" href="fmt/struct.Urn.html" title="struct uuid::fmt::Urn">Urn</a></h3></section></summary><div class="impl-items"><details class="rustdoc-toggle method-toggle" open><summary><section id="method.from-4" class="method trait-impl has-srclink"><span class="rightside"><a class="srclink" href="../src/uuid/fmt.rs.html#962-967">source</a></span><a href="#method.from-4" class="anchor"></a><h4 class="code-header">fn <a href="https://doc.rust-lang.org/nightly/core/convert/trait.From.html#tymethod.from" class="fnname">from</a>(f: <a class="struct" href="struct.Uuid.html" title="struct uuid::Uuid">Uuid</a>) -> Self</h4></section></summary><div class='docblock'><p>Converts to this type from the input type.</p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle" open><summary><section id="impl-From%3CUuid%3E-3" class="impl has-srclink"><span class="rightside"><a class="srclink" href="../src/uuid/fmt.rs.html#962-967">source</a></span><a href="#impl-From%3CUuid%3E-3" class="anchor"></a><h3 class="code-header in-band">impl <a class="trait" href="https://doc.rust-lang.org/nightly/core/convert/trait.From.html" title="trait core::convert::From">From</a><<a class="struct" href="struct.Uuid.html" title="struct uuid::Uuid">Uuid</a>> for <a class="struct" href="fmt/struct.Braced.html" title="struct uuid::fmt::Braced">Braced</a></h3></section></summary><div class="impl-items"><details class="rustdoc-toggle method-toggle" open><summary><section id="method.from-6" class="method trait-impl has-srclink"><span class="rightside"><a class="srclink" href="../src/uuid/fmt.rs.html#962-967">source</a></span><a href="#method.from-6" class="anchor"></a><h4 class="code-header">fn <a href="https://doc.rust-lang.org/nightly/core/convert/trait.From.html#tymethod.from" class="fnname">from</a>(f: <a class="struct" href="struct.Uuid.html" title="struct uuid::Uuid">Uuid</a>) -> Self</h4></section></summary><div class='docblock'><p>Converts to this type from the input type.</p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle" open><summary><section id="impl-FromStr" class="impl has-srclink"><span class="rightside"><a class="srclink" href="../src/uuid/parser.rs.html#22-28">source</a></span><a href="#impl-FromStr" class="anchor"></a><h3 class="code-header in-band">impl <a class="trait" href="https://doc.rust-lang.org/nightly/core/str/traits/trait.FromStr.html" title="trait core::str::traits::FromStr">FromStr</a> for <a class="struct" href="struct.Uuid.html" title="struct uuid::Uuid">Uuid</a></h3></section></summary><div class="impl-items"><details class="rustdoc-toggle" open><summary><section id="associatedtype.Err" class="associatedtype trait-impl has-srclink"><a href="#associatedtype.Err" class="anchor"></a><h4 class="code-header">type <a href="https://doc.rust-lang.org/nightly/core/str/traits/trait.FromStr.html#associatedtype.Err" class="associatedtype">Err</a> = <a class="struct" href="struct.Error.html" title="struct uuid::Error">Error</a></h4></section></summary><div class='docblock'><p>The associated error which can be returned from parsing.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><section id="method.from_str" class="method trait-impl has-srclink"><span class="rightside"><a class="srclink" href="../src/uuid/parser.rs.html#25-27">source</a></span><a href="#method.from_str" class="anchor"></a><h4 class="code-header">fn <a href="https://doc.rust-lang.org/nightly/core/str/traits/trait.FromStr.html#tymethod.from_str" class="fnname">from_str</a>(uuid_str: &<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.str.html">str</a>) -> <a class="enum" href="https://doc.rust-lang.org/nightly/core/result/enum.Result.html" title="enum core::result::Result">Result</a><Self, Self::<a class="associatedtype" href="https://doc.rust-lang.org/nightly/core/str/traits/trait.FromStr.html#associatedtype.Err" title="type core::str::traits::FromStr::Err">Err</a>></h4></section></summary><div class='docblock'><p>Parses a string <code>s</code> to return a value of this type. <a href="https://doc.rust-lang.org/nightly/core/str/traits/trait.FromStr.html#tymethod.from_str">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle" open><summary><section id="impl-Hash" class="impl has-srclink"><span class="rightside"><a class="srclink" href="../src/uuid/lib.rs.html#397">source</a></span><a href="#impl-Hash" class="anchor"></a><h3 class="code-header in-band">impl <a class="trait" href="https://doc.rust-lang.org/nightly/core/hash/trait.Hash.html" title="trait core::hash::Hash">Hash</a> for <a class="struct" href="struct.Uuid.html" title="struct uuid::Uuid">Uuid</a></h3></section></summary><div class="impl-items"><details class="rustdoc-toggle method-toggle" open><summary><section id="method.hash" class="method trait-impl has-srclink"><span class="rightside"><a class="srclink" href="../src/uuid/lib.rs.html#397">source</a></span><a href="#method.hash" class="anchor"></a><h4 class="code-header">fn <a href="https://doc.rust-lang.org/nightly/core/hash/trait.Hash.html#tymethod.hash" class="fnname">hash</a><__H: <a class="trait" href="https://doc.rust-lang.org/nightly/core/hash/trait.Hasher.html" title="trait core::hash::Hasher">Hasher</a>>(&self, state: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.reference.html">&mut </a>__H)</h4></section></summary><div class='docblock'><p>Feeds this value into the given <a href="https://doc.rust-lang.org/nightly/core/hash/trait.Hasher.html" title="Hasher"><code>Hasher</code></a>. <a href="https://doc.rust-lang.org/nightly/core/hash/trait.Hash.html#tymethod.hash">Read more</a></p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><section id="method.hash_slice" class="method trait-impl has-srclink"><span class="rightside"><span class="since" title="Stable since Rust version 1.3.0">1.3.0</span> · <a class="srclink" href="https://doc.rust-lang.org/nightly/src/core/hash/mod.rs.html#237-239">source</a></span><a href="#method.hash_slice" class="anchor"></a><h4 class="code-header">fn <a href="https://doc.rust-lang.org/nightly/core/hash/trait.Hash.html#method.hash_slice" class="fnname">hash_slice</a><H>(data: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.slice.html">&[Self]</a>, state: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.reference.html">&mut </a>H) <span class="where fmt-newline">where<br> H: <a class="trait" href="https://doc.rust-lang.org/nightly/core/hash/trait.Hasher.html" title="trait core::hash::Hasher">Hasher</a>, </span></h4></section></summary><div class='docblock'><p>Feeds a slice of this type into the given <a href="https://doc.rust-lang.org/nightly/core/hash/trait.Hasher.html" title="Hasher"><code>Hasher</code></a>. <a href="https://doc.rust-lang.org/nightly/core/hash/trait.Hash.html#method.hash_slice">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle" open><summary><section id="impl-LowerHex" class="impl has-srclink"><span class="rightside"><a class="srclink" href="../src/uuid/fmt.rs.html#43-51">source</a></span><a href="#impl-LowerHex" class="anchor"></a><h3 class="code-header in-band">impl <a class="trait" href="https://doc.rust-lang.org/nightly/core/fmt/trait.LowerHex.html" title="trait core::fmt::LowerHex">LowerHex</a> for <a class="struct" href="struct.Uuid.html" title="struct uuid::Uuid">Uuid</a></h3></section></summary><div class="impl-items"><details class="rustdoc-toggle method-toggle" open><summary><section id="method.fmt-2" class="method trait-impl has-srclink"><span class="rightside"><a class="srclink" href="../src/uuid/fmt.rs.html#44-50">source</a></span><a href="#method.fmt-2" class="anchor"></a><h4 class="code-header">fn <a href="https://doc.rust-lang.org/nightly/core/fmt/trait.LowerHex.html#tymethod.fmt" class="fnname">fmt</a>(&self, f: &mut <a class="struct" href="https://doc.rust-lang.org/nightly/core/fmt/struct.Formatter.html" title="struct core::fmt::Formatter">Formatter</a><'_>) -> <a class="type" href="https://doc.rust-lang.org/nightly/core/fmt/type.Result.html" title="type core::fmt::Result">Result</a></h4></section></summary><div class='docblock'><p>Formats the value using the given formatter.</p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle" open><summary><section id="impl-Ord" class="impl has-srclink"><span class="rightside"><a class="srclink" href="../src/uuid/lib.rs.html#397">source</a></span><a href="#impl-Ord" class="anchor"></a><h3 class="code-header in-band">impl <a class="trait" href="https://doc.rust-lang.org/nightly/core/cmp/trait.Ord.html" title="trait core::cmp::Ord">Ord</a> for <a class="struct" href="struct.Uuid.html" title="struct uuid::Uuid">Uuid</a></h3></section></summary><div class="impl-items"><details class="rustdoc-toggle method-toggle" open><summary><section id="method.cmp" class="method trait-impl has-srclink"><span class="rightside"><a class="srclink" href="../src/uuid/lib.rs.html#397">source</a></span><a href="#method.cmp" class="anchor"></a><h4 class="code-header">fn <a href="https://doc.rust-lang.org/nightly/core/cmp/trait.Ord.html#tymethod.cmp" class="fnname">cmp</a>(&self, other: &<a class="struct" href="struct.Uuid.html" title="struct uuid::Uuid">Uuid</a>) -> <a class="enum" href="https://doc.rust-lang.org/nightly/core/cmp/enum.Ordering.html" title="enum core::cmp::Ordering">Ordering</a></h4></section></summary><div class='docblock'><p>This method returns an <a href="https://doc.rust-lang.org/nightly/core/cmp/enum.Ordering.html" title="Ordering"><code>Ordering</code></a> between <code>self</code> and <code>other</code>. <a href="https://doc.rust-lang.org/nightly/core/cmp/trait.Ord.html#tymethod.cmp">Read more</a></p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><section id="method.max" class="method trait-impl has-srclink"><span class="rightside"><span class="since" title="Stable since Rust version 1.21.0">1.21.0</span> · <a class="srclink" href="https://doc.rust-lang.org/nightly/src/core/cmp.rs.html#796-798">source</a></span><a href="#method.max" class="anchor"></a><h4 class="code-header">fn <a href="https://doc.rust-lang.org/nightly/core/cmp/trait.Ord.html#method.max" class="fnname">max</a>(self, other: Self) -> Self</h4></section></summary><div class='docblock'><p>Compares and returns the maximum of two values. <a href="https://doc.rust-lang.org/nightly/core/cmp/trait.Ord.html#method.max">Read more</a></p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><section id="method.min" class="method trait-impl has-srclink"><span class="rightside"><span class="since" title="Stable since Rust version 1.21.0">1.21.0</span> · <a class="srclink" href="https://doc.rust-lang.org/nightly/src/core/cmp.rs.html#816-818">source</a></span><a href="#method.min" class="anchor"></a><h4 class="code-header">fn <a href="https://doc.rust-lang.org/nightly/core/cmp/trait.Ord.html#method.min" class="fnname">min</a>(self, other: Self) -> Self</h4></section></summary><div class='docblock'><p>Compares and returns the minimum of two values. <a href="https://doc.rust-lang.org/nightly/core/cmp/trait.Ord.html#method.min">Read more</a></p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><section id="method.clamp" class="method trait-impl has-srclink"><span class="rightside"><span class="since" title="Stable since Rust version 1.50.0">1.50.0</span> · <a class="srclink" href="https://doc.rust-lang.org/nightly/src/core/cmp.rs.html#841-843">source</a></span><a href="#method.clamp" class="anchor"></a><h4 class="code-header">fn <a href="https://doc.rust-lang.org/nightly/core/cmp/trait.Ord.html#method.clamp" class="fnname">clamp</a>(self, min: Self, max: Self) -> Self</h4></section></summary><div class='docblock'><p>Restrict a value to a certain interval. <a href="https://doc.rust-lang.org/nightly/core/cmp/trait.Ord.html#method.clamp">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle" open><summary><section id="impl-PartialEq%3CUuid%3E" class="impl has-srclink"><span class="rightside"><a class="srclink" href="../src/uuid/lib.rs.html#397">source</a></span><a href="#impl-PartialEq%3CUuid%3E" class="anchor"></a><h3 class="code-header in-band">impl <a class="trait" href="https://doc.rust-lang.org/nightly/core/cmp/trait.PartialEq.html" title="trait core::cmp::PartialEq">PartialEq</a><<a class="struct" href="struct.Uuid.html" title="struct uuid::Uuid">Uuid</a>> for <a class="struct" href="struct.Uuid.html" title="struct uuid::Uuid">Uuid</a></h3></section></summary><div class="impl-items"><details class="rustdoc-toggle method-toggle" open><summary><section id="method.eq" class="method trait-impl has-srclink"><span class="rightside"><a class="srclink" href="../src/uuid/lib.rs.html#397">source</a></span><a href="#method.eq" class="anchor"></a><h4 class="code-header">fn <a href="https://doc.rust-lang.org/nightly/core/cmp/trait.PartialEq.html#tymethod.eq" class="fnname">eq</a>(&self, other: &<a class="struct" href="struct.Uuid.html" title="struct uuid::Uuid">Uuid</a>) -> <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.bool.html">bool</a></h4></section></summary><div class='docblock'><p>This method tests for <code>self</code> and <code>other</code> values to be equal, and is used
by <code>==</code>. <a href="https://doc.rust-lang.org/nightly/core/cmp/trait.PartialEq.html#tymethod.eq">Read more</a></p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><section id="method.ne" class="method trait-impl has-srclink"><span class="rightside"><a class="srclink" href="../src/uuid/lib.rs.html#397">source</a></span><a href="#method.ne" class="anchor"></a><h4 class="code-header">fn <a href="https://doc.rust-lang.org/nightly/core/cmp/trait.PartialEq.html#method.ne" class="fnname">ne</a>(&self, other: &<a class="struct" href="struct.Uuid.html" title="struct uuid::Uuid">Uuid</a>) -> <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.bool.html">bool</a></h4></section></summary><div class='docblock'><p>This method tests for <code>!=</code>.</p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle" open><summary><section id="impl-PartialOrd%3CUuid%3E" class="impl has-srclink"><span class="rightside"><a class="srclink" href="../src/uuid/lib.rs.html#397">source</a></span><a href="#impl-PartialOrd%3CUuid%3E" class="anchor"></a><h3 class="code-header in-band">impl <a class="trait" href="https://doc.rust-lang.org/nightly/core/cmp/trait.PartialOrd.html" title="trait core::cmp::PartialOrd">PartialOrd</a><<a class="struct" href="struct.Uuid.html" title="struct uuid::Uuid">Uuid</a>> for <a class="struct" href="struct.Uuid.html" title="struct uuid::Uuid">Uuid</a></h3></section></summary><div class="impl-items"><details class="rustdoc-toggle method-toggle" open><summary><section id="method.partial_cmp" class="method trait-impl has-srclink"><span class="rightside"><a class="srclink" href="../src/uuid/lib.rs.html#397">source</a></span><a href="#method.partial_cmp" class="anchor"></a><h4 class="code-header">fn <a href="https://doc.rust-lang.org/nightly/core/cmp/trait.PartialOrd.html#tymethod.partial_cmp" class="fnname">partial_cmp</a>(&self, other: &<a class="struct" href="struct.Uuid.html" title="struct uuid::Uuid">Uuid</a>) -> <a class="enum" href="https://doc.rust-lang.org/nightly/core/option/enum.Option.html" title="enum core::option::Option">Option</a><<a class="enum" href="https://doc.rust-lang.org/nightly/core/cmp/enum.Ordering.html" title="enum core::cmp::Ordering">Ordering</a>></h4></section></summary><div class='docblock'><p>This method returns an ordering between <code>self</code> and <code>other</code> values if one exists. <a href="https://doc.rust-lang.org/nightly/core/cmp/trait.PartialOrd.html#tymethod.partial_cmp">Read more</a></p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><section id="method.lt" class="method trait-impl has-srclink"><span class="rightside"><span class="since" title="Stable since Rust version 1.0.0">1.0.0</span> · <a class="srclink" href="https://doc.rust-lang.org/nightly/src/core/cmp.rs.html#1100">source</a></span><a href="#method.lt" class="anchor"></a><h4 class="code-header">fn <a href="https://doc.rust-lang.org/nightly/core/cmp/trait.PartialOrd.html#method.lt" class="fnname">lt</a>(&self, other: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.reference.html">&</a>Rhs) -> <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.bool.html">bool</a></h4></section></summary><div class='docblock'><p>This method tests less than (for <code>self</code> and <code>other</code>) and is used by the <code><</code> operator. <a href="https://doc.rust-lang.org/nightly/core/cmp/trait.PartialOrd.html#method.lt">Read more</a></p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><section id="method.le" class="method trait-impl has-srclink"><span class="rightside"><span class="since" title="Stable since Rust version 1.0.0">1.0.0</span> · <a class="srclink" href="https://doc.rust-lang.org/nightly/src/core/cmp.rs.html#1120">source</a></span><a href="#method.le" class="anchor"></a><h4 class="code-header">fn <a href="https://doc.rust-lang.org/nightly/core/cmp/trait.PartialOrd.html#method.le" class="fnname">le</a>(&self, other: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.reference.html">&</a>Rhs) -> <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.bool.html">bool</a></h4></section></summary><div class='docblock'><p>This method tests less than or equal to (for <code>self</code> and <code>other</code>) and is used by the <code><=</code>
operator. <a href="https://doc.rust-lang.org/nightly/core/cmp/trait.PartialOrd.html#method.le">Read more</a></p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><section id="method.gt" class="method trait-impl has-srclink"><span class="rightside"><span class="since" title="Stable since Rust version 1.0.0">1.0.0</span> · <a class="srclink" href="https://doc.rust-lang.org/nightly/src/core/cmp.rs.html#1143">source</a></span><a href="#method.gt" class="anchor"></a><h4 class="code-header">fn <a href="https://doc.rust-lang.org/nightly/core/cmp/trait.PartialOrd.html#method.gt" class="fnname">gt</a>(&self, other: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.reference.html">&</a>Rhs) -> <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.bool.html">bool</a></h4></section></summary><div class='docblock'><p>This method tests greater than (for <code>self</code> and <code>other</code>) and is used by the <code>></code> operator. <a href="https://doc.rust-lang.org/nightly/core/cmp/trait.PartialOrd.html#method.gt">Read more</a></p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><section id="method.ge" class="method trait-impl has-srclink"><span class="rightside"><span class="since" title="Stable since Rust version 1.0.0">1.0.0</span> · <a class="srclink" href="https://doc.rust-lang.org/nightly/src/core/cmp.rs.html#1163">source</a></span><a href="#method.ge" class="anchor"></a><h4 class="code-header">fn <a href="https://doc.rust-lang.org/nightly/core/cmp/trait.PartialOrd.html#method.ge" class="fnname">ge</a>(&self, other: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.reference.html">&</a>Rhs) -> <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.bool.html">bool</a></h4></section></summary><div class='docblock'><p>This method tests greater than or equal to (for <code>self</code> and <code>other</code>) and is used by the <code>>=</code>
operator. <a href="https://doc.rust-lang.org/nightly/core/cmp/trait.PartialOrd.html#method.ge">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle" open><summary><section id="impl-TryFrom%3C%26%27_%20str%3E" class="impl has-srclink"><span class="rightside"><a class="srclink" href="../src/uuid/parser.rs.html#30-36">source</a></span><a href="#impl-TryFrom%3C%26%27_%20str%3E" class="anchor"></a><h3 class="code-header in-band">impl <a class="trait" href="https://doc.rust-lang.org/nightly/core/convert/trait.TryFrom.html" title="trait core::convert::TryFrom">TryFrom</a><&'_ <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.str.html">str</a>> for <a class="struct" href="struct.Uuid.html" title="struct uuid::Uuid">Uuid</a></h3></section></summary><div class="impl-items"><details class="rustdoc-toggle" open><summary><section id="associatedtype.Error" class="associatedtype trait-impl has-srclink"><a href="#associatedtype.Error" class="anchor"></a><h4 class="code-header">type <a href="https://doc.rust-lang.org/nightly/core/convert/trait.TryFrom.html#associatedtype.Error" class="associatedtype">Error</a> = <a class="struct" href="struct.Error.html" title="struct uuid::Error">Error</a></h4></section></summary><div class='docblock'><p>The type returned in the event of a conversion error.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><section id="method.try_from" class="method trait-impl has-srclink"><span class="rightside"><a class="srclink" href="../src/uuid/parser.rs.html#33-35">source</a></span><a href="#method.try_from" class="anchor"></a><h4 class="code-header">fn <a href="https://doc.rust-lang.org/nightly/core/convert/trait.TryFrom.html#tymethod.try_from" class="fnname">try_from</a>(uuid_str: &<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.str.html">str</a>) -> <a class="enum" href="https://doc.rust-lang.org/nightly/core/result/enum.Result.html" title="enum core::result::Result">Result</a><Self, Self::<a class="associatedtype" href="https://doc.rust-lang.org/nightly/core/convert/trait.TryFrom.html#associatedtype.Error" title="type core::convert::TryFrom::Error">Error</a>></h4></section></summary><div class='docblock'><p>Performs the conversion.</p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle" open><summary><section id="impl-UpperHex" class="impl has-srclink"><span class="rightside"><a class="srclink" href="../src/uuid/fmt.rs.html#53-62">source</a></span><a href="#impl-UpperHex" class="anchor"></a><h3 class="code-header in-band">impl <a class="trait" href="https://doc.rust-lang.org/nightly/core/fmt/trait.UpperHex.html" title="trait core::fmt::UpperHex">UpperHex</a> for <a class="struct" href="struct.Uuid.html" title="struct uuid::Uuid">Uuid</a></h3></section></summary><div class="impl-items"><details class="rustdoc-toggle method-toggle" open><summary><section id="method.fmt-3" class="method trait-impl has-srclink"><span class="rightside"><a class="srclink" href="../src/uuid/fmt.rs.html#55-61">source</a></span><a href="#method.fmt-3" class="anchor"></a><h4 class="code-header">fn <a href="https://doc.rust-lang.org/nightly/core/fmt/trait.UpperHex.html#tymethod.fmt" class="fnname">fmt</a>(&self, f: &mut <a class="struct" href="https://doc.rust-lang.org/nightly/core/fmt/struct.Formatter.html" title="struct core::fmt::Formatter">Formatter</a><'_>) -> <a class="type" href="https://doc.rust-lang.org/nightly/core/fmt/type.Result.html" title="type core::fmt::Result">Result</a></h4></section></summary><div class='docblock'><p>Formats the value using the given formatter.</p>
</div></details></div></details><section id="impl-Copy" class="impl has-srclink"><span class="rightside"><a class="srclink" href="../src/uuid/lib.rs.html#397">source</a></span><a href="#impl-Copy" class="anchor"></a><h3 class="code-header in-band">impl <a class="trait" href="https://doc.rust-lang.org/nightly/core/marker/trait.Copy.html" title="trait core::marker::Copy">Copy</a> for <a class="struct" href="struct.Uuid.html" title="struct uuid::Uuid">Uuid</a></h3></section><section id="impl-Eq" class="impl has-srclink"><span class="rightside"><a class="srclink" href="../src/uuid/lib.rs.html#397">source</a></span><a href="#impl-Eq" class="anchor"></a><h3 class="code-header in-band">impl <a class="trait" href="https://doc.rust-lang.org/nightly/core/cmp/trait.Eq.html" title="trait core::cmp::Eq">Eq</a> for <a class="struct" href="struct.Uuid.html" title="struct uuid::Uuid">Uuid</a></h3></section><section id="impl-StructuralEq" class="impl has-srclink"><span class="rightside"><a class="srclink" href="../src/uuid/lib.rs.html#397">source</a></span><a href="#impl-StructuralEq" class="anchor"></a><h3 class="code-header in-band">impl <a class="trait" href="https://doc.rust-lang.org/nightly/core/marker/trait.StructuralEq.html" title="trait core::marker::StructuralEq">StructuralEq</a> for <a class="struct" href="struct.Uuid.html" title="struct uuid::Uuid">Uuid</a></h3></section><section id="impl-StructuralPartialEq" class="impl has-srclink"><span class="rightside"><a class="srclink" href="../src/uuid/lib.rs.html#397">source</a></span><a href="#impl-StructuralPartialEq" class="anchor"></a><h3 class="code-header in-band">impl <a class="trait" href="https://doc.rust-lang.org/nightly/core/marker/trait.StructuralPartialEq.html" title="trait core::marker::StructuralPartialEq">StructuralPartialEq</a> for <a class="struct" href="struct.Uuid.html" title="struct uuid::Uuid">Uuid</a></h3></section></div><h2 id="synthetic-implementations" class="small-section-header">Auto Trait Implementations<a href="#synthetic-implementations" class="anchor"></a></h2><div id="synthetic-implementations-list"><section id="impl-RefUnwindSafe" class="impl has-srclink"><a href="#impl-RefUnwindSafe" class="anchor"></a><h3 class="code-header in-band">impl <a class="trait" href="https://doc.rust-lang.org/nightly/core/panic/unwind_safe/trait.RefUnwindSafe.html" title="trait core::panic::unwind_safe::RefUnwindSafe">RefUnwindSafe</a> for <a class="struct" href="struct.Uuid.html" title="struct uuid::Uuid">Uuid</a></h3></section><section id="impl-Send" class="impl has-srclink"><a href="#impl-Send" class="anchor"></a><h3 class="code-header in-band">impl <a class="trait" href="https://doc.rust-lang.org/nightly/core/marker/trait.Send.html" title="trait core::marker::Send">Send</a> for <a class="struct" href="struct.Uuid.html" title="struct uuid::Uuid">Uuid</a></h3></section><section id="impl-Sync" class="impl has-srclink"><a href="#impl-Sync" class="anchor"></a><h3 class="code-header in-band">impl <a class="trait" href="https://doc.rust-lang.org/nightly/core/marker/trait.Sync.html" title="trait core::marker::Sync">Sync</a> for <a class="struct" href="struct.Uuid.html" title="struct uuid::Uuid">Uuid</a></h3></section><section id="impl-Unpin" class="impl has-srclink"><a href="#impl-Unpin" class="anchor"></a><h3 class="code-header in-band">impl <a class="trait" href="https://doc.rust-lang.org/nightly/core/marker/trait.Unpin.html" title="trait core::marker::Unpin">Unpin</a> for <a class="struct" href="struct.Uuid.html" title="struct uuid::Uuid">Uuid</a></h3></section><section id="impl-UnwindSafe" class="impl has-srclink"><a href="#impl-UnwindSafe" class="anchor"></a><h3 class="code-header in-band">impl <a class="trait" href="https://doc.rust-lang.org/nightly/core/panic/unwind_safe/trait.UnwindSafe.html" title="trait core::panic::unwind_safe::UnwindSafe">UnwindSafe</a> for <a class="struct" href="struct.Uuid.html" title="struct uuid::Uuid">Uuid</a></h3></section></div><h2 id="blanket-implementations" class="small-section-header">Blanket Implementations<a href="#blanket-implementations" class="anchor"></a></h2><div id="blanket-implementations-list"><details class="rustdoc-toggle implementors-toggle"><summary><section id="impl-Any" class="impl has-srclink"><span class="rightside"><a class="srclink" href="https://doc.rust-lang.org/nightly/src/core/any.rs.html#132-136">source</a></span><a href="#impl-Any" class="anchor"></a><h3 class="code-header in-band">impl<T> <a class="trait" href="https://doc.rust-lang.org/nightly/core/any/trait.Any.html" title="trait core::any::Any">Any</a> for T <span class="where fmt-newline">where<br> T: 'static + ?<a class="trait" href="https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html" title="trait core::marker::Sized">Sized</a>, </span></h3></section></summary><div class="impl-items"><details class="rustdoc-toggle method-toggle" open><summary><section id="method.type_id" class="method trait-impl has-srclink"><span class="rightside"><a class="srclink" href="https://doc.rust-lang.org/nightly/src/core/any.rs.html#133">source</a></span><a href="#method.type_id" class="anchor"></a><h4 class="code-header">fn <a href="https://doc.rust-lang.org/nightly/core/any/trait.Any.html#tymethod.type_id" class="fnname">type_id</a>(&self) -> <a class="struct" href="https://doc.rust-lang.org/nightly/core/any/struct.TypeId.html" title="struct core::any::TypeId">TypeId</a></h4></section></summary><div class='docblock'><p>Gets the <code>TypeId</code> of <code>self</code>. <a href="https://doc.rust-lang.org/nightly/core/any/trait.Any.html#tymethod.type_id">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><section id="impl-Borrow%3CT%3E" class="impl has-srclink"><span class="rightside"><a class="srclink" href="https://doc.rust-lang.org/nightly/src/core/borrow.rs.html#209-214">source</a></span><a href="#impl-Borrow%3CT%3E" class="anchor"></a><h3 class="code-header in-band">impl<T> <a class="trait" href="https://doc.rust-lang.org/nightly/core/borrow/trait.Borrow.html" title="trait core::borrow::Borrow">Borrow</a><T> for T <span class="where fmt-newline">where<br> T: ?<a class="trait" href="https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html" title="trait core::marker::Sized">Sized</a>, </span></h3></section></summary><div class="impl-items"><details class="rustdoc-toggle method-toggle" open><summary><section id="method.borrow-4" class="method trait-impl has-srclink"><span class="rightside"><span class="since" title="const unstable">const: <a href="https://github.com/rust-lang/rust/issues/91522" title="Tracking issue for const_borrow">unstable</a></span> · <a class="srclink" href="https://doc.rust-lang.org/nightly/src/core/borrow.rs.html#211">source</a></span><a href="#method.borrow-4" class="anchor"></a><h4 class="code-header">fn <a href="https://doc.rust-lang.org/nightly/core/borrow/trait.Borrow.html#tymethod.borrow" class="fnname">borrow</a>(&self) -> <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.reference.html">&</a>T</h4></section></summary><div class='docblock'><p>Immutably borrows from an owned value. <a href="https://doc.rust-lang.org/nightly/core/borrow/trait.Borrow.html#tymethod.borrow">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><section id="impl-BorrowMut%3CT%3E" class="impl has-srclink"><span class="rightside"><a class="srclink" href="https://doc.rust-lang.org/nightly/src/core/borrow.rs.html#218-222">source</a></span><a href="#impl-BorrowMut%3CT%3E" class="anchor"></a><h3 class="code-header in-band">impl<T> <a class="trait" href="https://doc.rust-lang.org/nightly/core/borrow/trait.BorrowMut.html" title="trait core::borrow::BorrowMut">BorrowMut</a><T> for T <span class="where fmt-newline">where<br> T: ?<a class="trait" href="https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html" title="trait core::marker::Sized">Sized</a>, </span></h3></section></summary><div class="impl-items"><details class="rustdoc-toggle method-toggle" open><summary><section id="method.borrow_mut" class="method trait-impl has-srclink"><span class="rightside"><span class="since" title="const unstable">const: <a href="https://github.com/rust-lang/rust/issues/91522" title="Tracking issue for const_borrow">unstable</a></span> · <a class="srclink" href="https://doc.rust-lang.org/nightly/src/core/borrow.rs.html#219">source</a></span><a href="#method.borrow_mut" class="anchor"></a><h4 class="code-header">fn <a href="https://doc.rust-lang.org/nightly/core/borrow/trait.BorrowMut.html#tymethod.borrow_mut" class="fnname">borrow_mut</a>(&mut self) -> <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.reference.html">&mut </a>T</h4></section></summary><div class='docblock'><p>Mutably borrows from an owned value. <a href="https://doc.rust-lang.org/nightly/core/borrow/trait.BorrowMut.html#tymethod.borrow_mut">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><section id="impl-From%3CT%3E" class="impl has-srclink"><span class="rightside"><a class="srclink" href="https://doc.rust-lang.org/nightly/src/core/convert/mod.rs.html#557-562">source</a></span><a href="#impl-From%3CT%3E" class="anchor"></a><h3 class="code-header in-band">impl<T> <a class="trait" href="https://doc.rust-lang.org/nightly/core/convert/trait.From.html" title="trait core::convert::From">From</a><T> for T</h3></section></summary><div class="impl-items"><details class="rustdoc-toggle method-toggle" open><summary><section id="method.from-8" class="method trait-impl has-srclink"><span class="rightside"><span class="since" title="const unstable">const: <a href="https://github.com/rust-lang/rust/issues/88674" title="Tracking issue for const_convert">unstable</a></span> · <a class="srclink" href="https://doc.rust-lang.org/nightly/src/core/convert/mod.rs.html#559">source</a></span><a href="#method.from-8" class="anchor"></a><h4 class="code-header">fn <a href="https://doc.rust-lang.org/nightly/core/convert/trait.From.html#tymethod.from" class="fnname">from</a>(t: T) -> T</h4></section></summary><div class="docblock"><p>Returns the argument unchanged.</p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><section id="impl-Into%3CU%3E" class="impl has-srclink"><span class="rightside"><a class="srclink" href="https://doc.rust-lang.org/nightly/src/core/convert/mod.rs.html#541-552">source</a></span><a href="#impl-Into%3CU%3E" class="anchor"></a><h3 class="code-header in-band">impl<T, U> <a class="trait" href="https://doc.rust-lang.org/nightly/core/convert/trait.Into.html" title="trait core::convert::Into">Into</a><U> for T <span class="where fmt-newline">where<br> U: <a class="trait" href="https://doc.rust-lang.org/nightly/core/convert/trait.From.html" title="trait core::convert::From">From</a><T>, </span></h3></section></summary><div class="impl-items"><details class="rustdoc-toggle method-toggle" open><summary><section id="method.into" class="method trait-impl has-srclink"><span class="rightside"><span class="since" title="const unstable">const: <a href="https://github.com/rust-lang/rust/issues/88674" title="Tracking issue for const_convert">unstable</a></span> · <a class="srclink" href="https://doc.rust-lang.org/nightly/src/core/convert/mod.rs.html#549">source</a></span><a href="#method.into" class="anchor"></a><h4 class="code-header">fn <a href="https://doc.rust-lang.org/nightly/core/convert/trait.Into.html#tymethod.into" class="fnname">into</a>(self) -> U</h4></section></summary><div class="docblock"><p>Calls <code>U::from(self)</code>.</p>
<p>That is, this conversion is whatever the implementation of
<code><a href="https://doc.rust-lang.org/nightly/core/convert/trait.From.html" title="From">From</a><T> for U</code> chooses to do.</p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><section id="impl-ToOwned" class="impl has-srclink"><span class="rightside"><a class="srclink" href="https://doc.rust-lang.org/nightly/src/alloc/borrow.rs.html#84-96">source</a></span><a href="#impl-ToOwned" class="anchor"></a><h3 class="code-header in-band">impl<T> <a class="trait" href="https://doc.rust-lang.org/nightly/alloc/borrow/trait.ToOwned.html" title="trait alloc::borrow::ToOwned">ToOwned</a> for T <span class="where fmt-newline">where<br> T: <a class="trait" href="https://doc.rust-lang.org/nightly/core/clone/trait.Clone.html" title="trait core::clone::Clone">Clone</a>, </span></h3></section></summary><div class="impl-items"><details class="rustdoc-toggle" open><summary><section id="associatedtype.Owned" class="associatedtype trait-impl has-srclink"><a href="#associatedtype.Owned" class="anchor"></a><h4 class="code-header">type <a href="https://doc.rust-lang.org/nightly/alloc/borrow/trait.ToOwned.html#associatedtype.Owned" class="associatedtype">Owned</a> = T</h4></section></summary><div class='docblock'><p>The resulting type after obtaining ownership.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><section id="method.to_owned" class="method trait-impl has-srclink"><span class="rightside"><a class="srclink" href="https://doc.rust-lang.org/nightly/src/alloc/borrow.rs.html#89">source</a></span><a href="#method.to_owned" class="anchor"></a><h4 class="code-header">fn <a href="https://doc.rust-lang.org/nightly/alloc/borrow/trait.ToOwned.html#tymethod.to_owned" class="fnname">to_owned</a>(&self) -> T</h4></section></summary><div class='docblock'><p>Creates owned data from borrowed data, usually by cloning. <a href="https://doc.rust-lang.org/nightly/alloc/borrow/trait.ToOwned.html#tymethod.to_owned">Read more</a></p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><section id="method.clone_into" class="method trait-impl has-srclink"><span class="rightside"><a class="srclink" href="https://doc.rust-lang.org/nightly/src/alloc/borrow.rs.html#93">source</a></span><a href="#method.clone_into" class="anchor"></a><h4 class="code-header">fn <a href="https://doc.rust-lang.org/nightly/alloc/borrow/trait.ToOwned.html#method.clone_into" class="fnname">clone_into</a>(&self, target: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.reference.html">&mut </a>T)</h4></section></summary><span class="item-info"><div class="stab unstable"><span class="emoji">🔬</span> This is a nightly-only experimental API. (<code>toowned_clone_into</code>)</div></span><div class='docblock'><p>Uses borrowed data to replace owned data, usually by cloning. <a href="https://doc.rust-lang.org/nightly/alloc/borrow/trait.ToOwned.html#method.clone_into">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><section id="impl-ToString" class="impl has-srclink"><span class="rightside"><a class="srclink" href="https://doc.rust-lang.org/nightly/src/alloc/string.rs.html#2467-2481">source</a></span><a href="#impl-ToString" class="anchor"></a><h3 class="code-header in-band">impl<T> <a class="trait" href="https://doc.rust-lang.org/nightly/alloc/string/trait.ToString.html" title="trait alloc::string::ToString">ToString</a> for T <span class="where fmt-newline">where<br> T: <a class="trait" href="https://doc.rust-lang.org/nightly/core/fmt/trait.Display.html" title="trait core::fmt::Display">Display</a> + ?<a class="trait" href="https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html" title="trait core::marker::Sized">Sized</a>, </span></h3></section></summary><div class="impl-items"><details class="rustdoc-toggle method-toggle" open><summary><section id="method.to_string" class="method trait-impl has-srclink"><span class="rightside"><a class="srclink" href="https://doc.rust-lang.org/nightly/src/alloc/string.rs.html#2473">source</a></span><a href="#method.to_string" class="anchor"></a><h4 class="code-header">default fn <a href="https://doc.rust-lang.org/nightly/alloc/string/trait.ToString.html#tymethod.to_string" class="fnname">to_string</a>(&self) -> <a class="struct" href="https://doc.rust-lang.org/nightly/alloc/string/struct.String.html" title="struct alloc::string::String">String</a></h4></section></summary><div class='docblock'><p>Converts the given value to a <code>String</code>. <a href="https://doc.rust-lang.org/nightly/alloc/string/trait.ToString.html#tymethod.to_string">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><section id="impl-TryFrom%3CU%3E" class="impl has-srclink"><span class="rightside"><a class="srclink" href="https://doc.rust-lang.org/nightly/src/core/convert/mod.rs.html#598-607">source</a></span><a href="#impl-TryFrom%3CU%3E" class="anchor"></a><h3 class="code-header in-band">impl<T, U> <a class="trait" href="https://doc.rust-lang.org/nightly/core/convert/trait.TryFrom.html" title="trait core::convert::TryFrom">TryFrom</a><U> for T <span class="where fmt-newline">where<br> U: <a class="trait" href="https://doc.rust-lang.org/nightly/core/convert/trait.Into.html" title="trait core::convert::Into">Into</a><T>, </span></h3></section></summary><div class="impl-items"><details class="rustdoc-toggle" open><summary><section id="associatedtype.Error-1" class="associatedtype trait-impl has-srclink"><a href="#associatedtype.Error-1" class="anchor"></a><h4 class="code-header">type <a href="https://doc.rust-lang.org/nightly/core/convert/trait.TryFrom.html#associatedtype.Error" class="associatedtype">Error</a> = <a class="enum" href="https://doc.rust-lang.org/nightly/core/convert/enum.Infallible.html" title="enum core::convert::Infallible">Infallible</a></h4></section></summary><div class='docblock'><p>The type returned in the event of a conversion error.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><section id="method.try_from-1" class="method trait-impl has-srclink"><span class="rightside"><span class="since" title="const unstable">const: <a href="https://github.com/rust-lang/rust/issues/88674" title="Tracking issue for const_convert">unstable</a></span> · <a class="srclink" href="https://doc.rust-lang.org/nightly/src/core/convert/mod.rs.html#604">source</a></span><a href="#method.try_from-1" class="anchor"></a><h4 class="code-header">fn <a href="https://doc.rust-lang.org/nightly/core/convert/trait.TryFrom.html#tymethod.try_from" class="fnname">try_from</a>(value: U) -> <a class="enum" href="https://doc.rust-lang.org/nightly/core/result/enum.Result.html" title="enum core::result::Result">Result</a><T, <T as <a class="trait" href="https://doc.rust-lang.org/nightly/core/convert/trait.TryFrom.html" title="trait core::convert::TryFrom">TryFrom</a><U>>::<a class="associatedtype" href="https://doc.rust-lang.org/nightly/core/convert/trait.TryFrom.html#associatedtype.Error" title="type core::convert::TryFrom::Error">Error</a>></h4></section></summary><div class='docblock'><p>Performs the conversion.</p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><section id="impl-TryInto%3CU%3E" class="impl has-srclink"><span class="rightside"><a class="srclink" href="https://doc.rust-lang.org/nightly/src/core/convert/mod.rs.html#583-592">source</a></span><a href="#impl-TryInto%3CU%3E" class="anchor"></a><h3 class="code-header in-band">impl<T, U> <a class="trait" href="https://doc.rust-lang.org/nightly/core/convert/trait.TryInto.html" title="trait core::convert::TryInto">TryInto</a><U> for T <span class="where fmt-newline">where<br> U: <a class="trait" href="https://doc.rust-lang.org/nightly/core/convert/trait.TryFrom.html" title="trait core::convert::TryFrom">TryFrom</a><T>, </span></h3></section></summary><div class="impl-items"><details class="rustdoc-toggle" open><summary><section id="associatedtype.Error-2" class="associatedtype trait-impl has-srclink"><a href="#associatedtype.Error-2" class="anchor"></a><h4 class="code-header">type <a href="https://doc.rust-lang.org/nightly/core/convert/trait.TryInto.html#associatedtype.Error" class="associatedtype">Error</a> = <U as <a class="trait" href="https://doc.rust-lang.org/nightly/core/convert/trait.TryFrom.html" title="trait core::convert::TryFrom">TryFrom</a><T>>::<a class="associatedtype" href="https://doc.rust-lang.org/nightly/core/convert/trait.TryFrom.html#associatedtype.Error" title="type core::convert::TryFrom::Error">Error</a></h4></section></summary><div class='docblock'><p>The type returned in the event of a conversion error.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><section id="method.try_into" class="method trait-impl has-srclink"><span class="rightside"><span class="since" title="const unstable">const: <a href="https://github.com/rust-lang/rust/issues/88674" title="Tracking issue for const_convert">unstable</a></span> · <a class="srclink" href="https://doc.rust-lang.org/nightly/src/core/convert/mod.rs.html#589">source</a></span><a href="#method.try_into" class="anchor"></a><h4 class="code-header">fn <a href="https://doc.rust-lang.org/nightly/core/convert/trait.TryInto.html#tymethod.try_into" class="fnname">try_into</a>(self) -> <a class="enum" href="https://doc.rust-lang.org/nightly/core/result/enum.Result.html" title="enum core::result::Result">Result</a><U, <U as <a class="trait" href="https://doc.rust-lang.org/nightly/core/convert/trait.TryFrom.html" title="trait core::convert::TryFrom">TryFrom</a><T>>::<a class="associatedtype" href="https://doc.rust-lang.org/nightly/core/convert/trait.TryFrom.html#associatedtype.Error" title="type core::convert::TryFrom::Error">Error</a>></h4></section></summary><div class='docblock'><p>Performs the conversion.</p>
</div></details></div></details></div></section><section id="search" class="content hidden"></section></div></main><div id="rustdoc-vars" data-root-path="../" data-current-crate="uuid" data-themes="ayu,dark,light" data-resource-suffix="" data-rustdoc-version="1.62.0-nightly (de1bc0008 2022-04-21)" ></div>
</body></html>