rust/tantivy
1
0
Fork 0
mirror of https://github.com/quickwit-oss/tantivy.git synced 2026-05-20 10:10:42 +00:00
Code Issues Packages Projects Releases Wiki Activity

Automatic Travis documentation build

Browse Source
This commit is contained in:
Travis CI User
2018-03-10 05:24:44 +00:00
parent 15084a9427
commit 4cff7cb182
8 changed files with 246 additions and 103 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
master/lazy_static/fn.initialize.html
View File

@@ -59,7 +59,7 @@
<a id="toggle-all-docs" href="javascript:void(0)" title="collapse all docs">
[<span class='inner'>&#x2212;</span>]
</a>
</span><a class='srclink' href='../src/lazy_static/lib.rs.html#220-222' title='goto source code'>[src]</a></span></h1>
</span><a class='srclink' href='../src/lazy_static/lib.rs.html#210-212' title='goto source code'>[src]</a></span></h1>
<pre class='rust fn'>pub fn initialize&lt;T:&nbsp;<a class="trait" href="../lazy_static/trait.LazyStatic.html" title="trait lazy_static::LazyStatic">LazyStatic</a>&gt;(lazy: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.reference.html">&amp;</a>T)</pre><div class='docblock'><p>Takes a shared reference to a lazy static and initializes
it if it has not been already.</p>
<p>This can be used to control the initialization point of a lazy static.</p>

53
master/lazy_static/index.html
View File

@@ -33,7 +33,7 @@
<nav class="sidebar">
<div class="sidebar-menu">&#9776;</div>
<p class='location'>Crate lazy_static</p><div class="sidebar-elems"><div class="block items"><ul><li><a href="#macros">Macros</a></li></ul></div><p class='location'></p><script>window.sidebarCurrent = {name: 'lazy_static', ty: 'mod', relpath: '../'};</script></div>
<p class='location'>Crate lazy_static</p><div class="sidebar-elems"><div class="block items"><ul><li><a href="#macros">Macros</a></li><li><a href="#traits">Traits</a></li><li><a href="#functions">Functions</a></li></ul></div><p class='location'></p><script>window.sidebarCurrent = {name: 'lazy_static', ty: 'mod', relpath: '../'};</script></div>
</nav>
<div class="theme-picker">
@@ -59,7 +59,7 @@
<a id="toggle-all-docs" href="javascript:void(0)" title="collapse all docs">
[<span class='inner'>&#x2212;</span>]
</a>
</span><a class='srclink' href='../src/lazy_static/lib.rs.html#1-157' title='goto source code'>[src]</a></span></h1>
</span><a class='srclink' href='../src/lazy_static/lib.rs.html#8-212' title='goto source code'>[src]</a></span></h1>
<div class='docblock'><p>A macro for declaring lazily evaluated statics.</p>
<p>Using this macro, it is possible to have <code>static</code>s that require code to be
executed at runtime in order to be initialized.
@@ -73,15 +73,26 @@ as well as anything that requires function calls to be computed.</p>
...
[<span class="kw">pub</span>] <span class="kw">static</span> <span class="kw-2">ref</span> <span class="ident">NAME_N</span>: <span class="ident">TYPE_N</span> <span class="op">=</span> <span class="ident">EXPR_N</span>;
}</pre>
<p>Metadata (such as doc comments) is allowed on each ref.</p>
<h1 id="semantic" class="section-header"><a href="#semantic">Semantic</a></h1>
<p>Attributes (including doc comments) are supported as well:</p>
<pre class="rust rust-example-rendered">
<span class="macro">lazy_static</span><span class="macro">!</span> {
<span class="doccomment">/// This is an example for using doc comment attributes</span>
<span class="kw">static</span> <span class="kw-2">ref</span> <span class="ident">EXAMPLE</span>: <span class="ident">u8</span> <span class="op">=</span> <span class="number">42</span>;
}</pre>
<h1 id="semantics" class="section-header"><a href="#semantics">Semantics</a></h1>
<p>For a given <code>static ref NAME: TYPE = EXPR;</code>, the macro generates a unique type that
implements <code>Deref&lt;TYPE&gt;</code> and stores it in a static with name <code>NAME</code>. (Metadata ends up
implements <code>Deref&lt;TYPE&gt;</code> and stores it in a static with name <code>NAME</code>. (Attributes end up
attaching to this type.)</p>
<p>On first deref, <code>EXPR</code> gets evaluated and stored internally, such that all further derefs
can return a reference to the same object.</p>
<p>Like regular <code>static mut</code>s, this macro only works for types that fulfill the <code>Sync</code>
trait.</p>
can return a reference to the same object. Note that this can lead to deadlocks
if you have multiple lazy statics that depend on each other in their initialization.</p>
<p>Apart from the lazy initialization, the resulting &quot;static ref&quot; variables
have generally the same properties as regular &quot;static&quot; variables:</p>
<ul>
<li>Any type in them needs to fulfill the <code>Sync</code> trait.</li>
<li>If the type has a destructor, then it will not run when the process exits.</li>
</ul>
<h1 id="example" class="section-header"><a href="#example">Example</a></h1>
<p>Using the macro:</p>
@@ -114,11 +125,37 @@ trait.</p>
<p>The <code>Deref</code> implementation uses a hidden static variable that is guarded by a atomic check on each access. On stable Rust, the macro may need to allocate each static on the heap.</p>
</div><h2 id='macros' class='section-header'><a href="#macros">Macros</a></h2>
<table>
<tr class=' module-item'>
<td><a class="macro" href="macro.__lazy_static_create.html"
title='macro lazy_static::__lazy_static_create'>__lazy_static_create</a></td>
<td class='docblock-short'>
</td>
</tr>
<tr class=' module-item'>
<td><a class="macro" href="macro.lazy_static.html"
title='macro lazy_static::lazy_static'>lazy_static</a></td>
<td class='docblock-short'>
</td>
</tr></table><h2 id='traits' class='section-header'><a href="#traits">Traits</a></h2>
<table>
<tr class=' module-item'>
<td><a class="trait" href="trait.LazyStatic.html"
title='trait lazy_static::LazyStatic'>LazyStatic</a></td>
<td class='docblock-short'>
<p>Support trait for enabling a few common operation on lazy static values.</p>
</td>
</tr></table><h2 id='functions' class='section-header'><a href="#functions">Functions</a></h2>
<table>
<tr class=' module-item'>
<td><a class="fn" href="fn.initialize.html"
title='fn lazy_static::initialize'>initialize</a></td>
<td class='docblock-short'>
<p>Takes a shared reference to a lazy static and initializes
it if it has not been already.</p>
</td>
</tr></table></section>
<section id='search' class="content hidden"></section>

6
master/lazy_static/macro.lazy_static.html
View File

@@ -59,14 +59,12 @@
<a id="toggle-all-docs" href="javascript:void(0)" title="collapse all docs">
[<span class='inner'>&#x2212;</span>]
</a>
</span><a class='srclink' href='../src/lazy_static/lib.rs.html#75-157' title='goto source code'>[src]</a></span></h1>
</span><a class='srclink' href='../src/lazy_static/lib.rs.html#164-176' title='goto source code'>[src]</a></span></h1>
<pre class="rust macro">
<span class="macro">macro_rules</span><span class="macro">!</span> <span class="ident">lazy_static</span> {
($(<span class="attribute">#[<span class="macro-nonterminal">$</span><span class="macro-nonterminal">attr</span>:<span class="ident">meta</span>]</span>)<span class="op">*</span> <span class="kw">static</span> <span class="kw-2">ref</span> <span class="macro-nonterminal">$</span><span class="macro-nonterminal">N</span>:<span class="ident">ident</span> : <span class="macro-nonterminal">$</span><span class="macro-nonterminal">T</span>:<span class="ident">ty</span> <span class="op">=</span> <span class="macro-nonterminal">$</span><span class="macro-nonterminal">e</span>:<span class="ident">expr</span>; $(<span class="macro-nonterminal">$</span><span class="macro-nonterminal">t</span>:<span class="ident">tt</span>)<span class="kw-2">*</span>) <span class="op">=&gt;</span> { ... };
($(<span class="attribute">#[<span class="macro-nonterminal">$</span><span class="macro-nonterminal">attr</span>:<span class="ident">meta</span>]</span>)<span class="op">*</span> <span class="kw">pub</span> <span class="kw">static</span> <span class="kw-2">ref</span> <span class="macro-nonterminal">$</span><span class="macro-nonterminal">N</span>:<span class="ident">ident</span> : <span class="macro-nonterminal">$</span><span class="macro-nonterminal">T</span>:<span class="ident">ty</span> <span class="op">=</span> <span class="macro-nonterminal">$</span><span class="macro-nonterminal">e</span>:<span class="ident">expr</span>; $(<span class="macro-nonterminal">$</span><span class="macro-nonterminal">t</span>:<span class="ident">tt</span>)<span class="kw-2">*</span>) <span class="op">=&gt;</span> { ... };
(<span class="macro-nonterminal">$</span><span class="macro-nonterminal">VIS</span>:<span class="ident">ident</span>, $(<span class="attribute">#[<span class="macro-nonterminal">$</span><span class="macro-nonterminal">attr</span>:<span class="ident">meta</span>]</span>)<span class="op">*</span> <span class="kw">static</span> <span class="kw-2">ref</span> <span class="macro-nonterminal">$</span><span class="macro-nonterminal">N</span>:<span class="ident">ident</span> : <span class="macro-nonterminal">$</span><span class="macro-nonterminal">T</span>:<span class="ident">ty</span> <span class="op">=</span> <span class="macro-nonterminal">$</span><span class="macro-nonterminal">e</span>:<span class="ident">expr</span>; $(<span class="macro-nonterminal">$</span><span class="macro-nonterminal">t</span>:<span class="ident">tt</span>)<span class="kw-2">*</span>) <span class="op">=&gt;</span> { ... };
(<span class="ident">MAKE</span> <span class="ident">TY</span>, <span class="ident">PUB</span>, $(<span class="attribute">#[<span class="macro-nonterminal">$</span><span class="macro-nonterminal">attr</span>:<span class="ident">meta</span>]</span>)<span class="kw-2">*</span>, <span class="macro-nonterminal">$</span><span class="macro-nonterminal">N</span>:<span class="ident">ident</span>) <span class="op">=&gt;</span> { ... };
(<span class="ident">MAKE</span> <span class="ident">TY</span>, <span class="ident">PRIV</span>, $(<span class="attribute">#[<span class="macro-nonterminal">$</span><span class="macro-nonterminal">attr</span>:<span class="ident">meta</span>]</span>)<span class="kw-2">*</span>, <span class="macro-nonterminal">$</span><span class="macro-nonterminal">N</span>:<span class="ident">ident</span>) <span class="op">=&gt;</span> { ... };
($(<span class="attribute">#[<span class="macro-nonterminal">$</span><span class="macro-nonterminal">attr</span>:<span class="ident">meta</span>]</span>)<span class="op">*</span> <span class="kw">pub</span> ($(<span class="macro-nonterminal">$</span><span class="macro-nonterminal">vis</span>:<span class="ident">tt</span>)<span class="op">+</span>) <span class="kw">static</span> <span class="kw-2">ref</span> <span class="macro-nonterminal">$</span><span class="macro-nonterminal">N</span>:<span class="ident">ident</span> : <span class="macro-nonterminal">$</span><span class="macro-nonterminal">T</span>:<span class="ident">ty</span> <span class="op">=</span> <span class="macro-nonterminal">$</span><span class="macro-nonterminal">e</span>:<span class="ident">expr</span>; $(<span class="macro-nonterminal">$</span><span class="macro-nonterminal">t</span>:<span class="ident">tt</span>)<span class="kw-2">*</span>) <span class="op">=&gt;</span> { ... };
() <span class="op">=&gt;</span> { ... };
}</pre>
</section>

2
master/lazy_static/sidebar-items.js
View File

@@ -1 +1 @@
initSidebarItems({"macro":[["lazy_static",""]]});
initSidebarItems({"fn":[["initialize","Takes a shared reference to a lazy static and initializes it if it has not been already."]],"macro":[["__lazy_static_create",""],["lazy_static",""]],"trait":[["LazyStatic","Support trait for enabling a few common operation on lazy static values."]]});

2
master/lazy_static/trait.LazyStatic.html
View File

@@ -59,7 +59,7 @@
<a id="toggle-all-docs" href="javascript:void(0)" title="collapse all docs">
[<span class='inner'>&#x2212;</span>]
</a>
</span><a class='srclink' href='../src/lazy_static/lib.rs.html#192-195' title='goto source code'>[src]</a></span></h1>
</span><a class='srclink' href='../src/lazy_static/lib.rs.html#182-185' title='goto source code'>[src]</a></span></h1>
<pre class='rust trait'>pub trait LazyStatic { }</pre><div class='docblock'><p>Support trait for enabling a few common operation on lazy static values.</p>
<p>This is implemented by each defined lazy static, and
used by the free functions in this crate.</p>

2
master/search-index.js
View File

File diff suppressed because one or more lines are too long

4
master/src/lazy_static/lazy.rs.html
View File

@@ -4,7 +4,7 @@
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<meta name="generator" content="rustdoc">
<meta name="description" content="Source to the Rust file `/home/travis/.cargo/registry/src/github.com-1ecc6299db9ec823/lazy_static-1.0.0/src/lazy.rs`.">
<meta name="description" content="Source to the Rust file `/home/travis/.cargo/registry/src/github.com-1ecc6299db9ec823/lazy_static-0.2.11/src/lazy.rs`.">
<meta name="keywords" content="rust, rustlang, rust-lang">
<title>lazy.rs.html -- source</title>
@@ -93,7 +93,6 @@
<span id="37">37</span>
<span id="38">38</span>
<span id="39">39</span>
<span id="40">40</span>
</pre><pre class="rust ">
<span class="comment">// Copyright 2016 lazy-static.rs Developers</span>
<span class="comment">//</span>
@@ -129,7 +128,6 @@
<span class="kw">unsafe</span> <span class="kw">impl</span><span class="op">&lt;</span><span class="ident">T</span>: <span class="ident">Sync</span><span class="op">&gt;</span> <span class="ident">Sync</span> <span class="kw">for</span> <span class="ident">Lazy</span><span class="op">&lt;</span><span class="ident">T</span><span class="op">&gt;</span> {}
<span class="attribute">#[<span class="ident">macro_export</span>]</span>
<span class="attribute">#[<span class="ident">doc</span>(<span class="ident">hidden</span>)]</span>
<span class="macro">macro_rules</span><span class="macro">!</span> <span class="ident">__lazy_static_create</span> {
(<span class="macro-nonterminal">$</span><span class="macro-nonterminal">NAME</span>:<span class="ident">ident</span>, <span class="macro-nonterminal">$</span><span class="macro-nonterminal">T</span>:<span class="ident">ty</span>) <span class="op">=&gt;</span> {
<span class="kw">static</span> <span class="kw-2">mut</span> <span class="macro-nonterminal">$</span><span class="macro-nonterminal">NAME</span>: <span class="macro-nonterminal">$</span><span class="kw">crate</span>::<span class="macro-nonterminal">lazy</span>::<span class="ident">Lazy</span><span class="op">&lt;</span><span class="macro-nonterminal">$</span><span class="macro-nonterminal">T</span><span class="op">&gt;</span> <span class="op">=</span> <span class="macro-nonterminal">$</span><span class="kw">crate</span>::<span class="macro-nonterminal">lazy</span>::<span class="ident">Lazy</span>(<span class="number">0</span> <span class="kw">as</span> <span class="kw-2">*</span><span class="kw">const</span> <span class="macro-nonterminal">$</span><span class="macro-nonterminal">T</span>, <span class="macro-nonterminal">$</span><span class="kw">crate</span>::<span class="macro-nonterminal">lazy</span>::<span class="ident">ONCE_INIT</span>);

278
master/src/lazy_static/lib.rs.html
View File

@@ -4,7 +4,7 @@
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<meta name="generator" content="rustdoc">
<meta name="description" content="Source to the Rust file `/home/travis/.cargo/registry/src/github.com-1ecc6299db9ec823/lazy_static-0.1.16/src/lib.rs`.">
<meta name="description" content="Source to the Rust file `/home/travis/.cargo/registry/src/github.com-1ecc6299db9ec823/lazy_static-0.2.11/src/lib.rs`.">
<meta name="keywords" content="rust, rustlang, rust-lang">
<title>lib.rs.html -- source</title>
@@ -211,7 +211,69 @@
<span id="155">155</span>
<span id="156">156</span>
<span id="157">157</span>
<span id="158">158</span>
<span id="159">159</span>
<span id="160">160</span>
<span id="161">161</span>
<span id="162">162</span>
<span id="163">163</span>
<span id="164">164</span>
<span id="165">165</span>
<span id="166">166</span>
<span id="167">167</span>
<span id="168">168</span>
<span id="169">169</span>
<span id="170">170</span>
<span id="171">171</span>
<span id="172">172</span>
<span id="173">173</span>
<span id="174">174</span>
<span id="175">175</span>
<span id="176">176</span>
<span id="177">177</span>
<span id="178">178</span>
<span id="179">179</span>
<span id="180">180</span>
<span id="181">181</span>
<span id="182">182</span>
<span id="183">183</span>
<span id="184">184</span>
<span id="185">185</span>
<span id="186">186</span>
<span id="187">187</span>
<span id="188">188</span>
<span id="189">189</span>
<span id="190">190</span>
<span id="191">191</span>
<span id="192">192</span>
<span id="193">193</span>
<span id="194">194</span>
<span id="195">195</span>
<span id="196">196</span>
<span id="197">197</span>
<span id="198">198</span>
<span id="199">199</span>
<span id="200">200</span>
<span id="201">201</span>
<span id="202">202</span>
<span id="203">203</span>
<span id="204">204</span>
<span id="205">205</span>
<span id="206">206</span>
<span id="207">207</span>
<span id="208">208</span>
<span id="209">209</span>
<span id="210">210</span>
<span id="211">211</span>
<span id="212">212</span>
</pre><pre class="rust ">
<span class="comment">// Copyright 2016 lazy-static.rs Developers</span>
<span class="comment">//</span>
<span class="comment">// Licensed under the Apache License, Version 2.0, &lt;LICENSE-APACHE or</span>
<span class="comment">// http://apache.org/licenses/LICENSE-2.0&gt; or the MIT license &lt;LICENSE-MIT or</span>
<span class="comment">// http://opensource.org/licenses/MIT&gt;, at your option. This file may not be</span>
<span class="comment">// copied, modified, or distributed except according to those terms.</span>
<span class="doccomment">/*!
A macro for declaring lazily evaluated statics.
@@ -231,19 +293,34 @@ lazy_static! {
}
```
Metadata (such as doc comments) is allowed on each ref.
Attributes (including doc comments) are supported as well:
# Semantic
```rust
# #[macro_use]
# extern crate lazy_static;
# fn main() {
lazy_static! {
/// This is an example for using doc comment attributes
static ref EXAMPLE: u8 = 42;
}
# }
```
# Semantics
For a given `static ref NAME: TYPE = EXPR;`, the macro generates a unique type that
implements `Deref&lt;TYPE&gt;` and stores it in a static with name `NAME`. (Metadata ends up
implements `Deref&lt;TYPE&gt;` and stores it in a static with name `NAME`. (Attributes end up
attaching to this type.)
On first deref, `EXPR` gets evaluated and stored internally, such that all further derefs
can return a reference to the same object.
can return a reference to the same object. Note that this can lead to deadlocks
if you have multiple lazy statics that depend on each other in their initialization.
Like regular `static mut`s, this macro only works for types that fulfill the `Sync`
trait.
Apart from the lazy initialization, the resulting &quot;static ref&quot; variables
have generally the same properties as regular &quot;static&quot; variables:
- Any type in them needs to fulfill the `Sync` trait.
- If the type has a destructor, then it will not run when the process exits.
# Example
@@ -282,93 +359,126 @@ The `Deref` implementation uses a hidden static variable that is guarded by a at
*/</span>
<span class="attribute">#![<span class="ident">cfg_attr</span>(<span class="ident">feature</span><span class="op">=</span><span class="string">&quot;nightly&quot;</span>, <span class="ident">feature</span>(<span class="ident">const_fn</span>, <span class="ident">core_intrinsics</span>))]</span>
<span class="attribute">#![<span class="ident">crate_type</span> <span class="op">=</span> <span class="string">&quot;dylib&quot;</span>]</span>
<span class="attribute">#![<span class="ident">cfg_attr</span>(<span class="ident">feature</span><span class="op">=</span><span class="string">&quot;spin_no_std&quot;</span>, <span class="ident">feature</span>(<span class="ident">const_fn</span>))]</span>
<span class="attribute">#![<span class="ident">cfg_attr</span>(<span class="ident">feature</span><span class="op">=</span><span class="string">&quot;nightly&quot;</span>, <span class="ident">feature</span>(<span class="ident">unreachable</span>))]</span>
<span class="attribute">#![<span class="ident">doc</span>(<span class="ident">html_root_url</span> <span class="op">=</span> <span class="string">&quot;https://docs.rs/lazy_static/0.2.11&quot;</span>)]</span>
<span class="attribute">#![<span class="ident">no_std</span>]</span>
<span class="attribute">#[<span class="ident">cfg</span>(<span class="ident">not</span>(<span class="ident">feature</span><span class="op">=</span><span class="string">&quot;nightly&quot;</span>))]</span>
<span class="attribute">#[<span class="ident">doc</span>(<span class="ident">hidden</span>)]</span>
<span class="kw">pub</span> <span class="kw">mod</span> <span class="ident">lazy</span>;
<span class="attribute">#[<span class="ident">cfg</span>(<span class="ident">all</span>(<span class="ident">feature</span><span class="op">=</span><span class="string">&quot;nightly&quot;</span>, <span class="ident">not</span>(<span class="ident">feature</span><span class="op">=</span><span class="string">&quot;spin_no_std&quot;</span>)))]</span>
<span class="attribute">#[<span class="ident">path</span><span class="op">=</span><span class="string">&quot;nightly_lazy.rs&quot;</span>]</span>
<span class="attribute">#[<span class="ident">doc</span>(<span class="ident">hidden</span>)]</span>
<span class="kw">pub</span> <span class="kw">mod</span> <span class="ident">lazy</span>;
<span class="attribute">#[<span class="ident">cfg</span>(<span class="ident">all</span>(<span class="ident">feature</span><span class="op">=</span><span class="string">&quot;nightly&quot;</span>, <span class="ident">feature</span><span class="op">=</span><span class="string">&quot;spin_no_std&quot;</span>))]</span>
<span class="attribute">#[<span class="ident">path</span><span class="op">=</span><span class="string">&quot;core_lazy.rs&quot;</span>]</span>
<span class="attribute">#[<span class="ident">doc</span>(<span class="ident">hidden</span>)]</span>
<span class="kw">pub</span> <span class="kw">mod</span> <span class="ident">lazy</span>;
<span class="attribute">#[<span class="ident">doc</span>(<span class="ident">hidden</span>)]</span>
<span class="kw">pub</span> <span class="kw">use</span> <span class="ident">core</span>::<span class="ident">ops</span>::<span class="ident">Deref</span> <span class="kw">as</span> <span class="ident">__Deref</span>;
<span class="attribute">#[<span class="ident">macro_export</span>]</span>
<span class="attribute">#[<span class="ident">doc</span>(<span class="ident">hidden</span>)]</span>
<span class="macro">macro_rules</span><span class="macro">!</span> <span class="ident">__lazy_static_internal</span> {
<span class="comment">// optional visibility restrictions are wrapped in `()` to allow for</span>
<span class="comment">// explicitly passing otherwise implicit information about private items</span>
($(<span class="attribute">#[<span class="macro-nonterminal">$</span><span class="macro-nonterminal">attr</span>:<span class="ident">meta</span>]</span>)<span class="op">*</span> ($(<span class="macro-nonterminal">$</span><span class="macro-nonterminal">vis</span>:<span class="ident">tt</span>)<span class="kw-2">*</span>) <span class="kw">static</span> <span class="kw-2">ref</span> <span class="macro-nonterminal">$</span><span class="macro-nonterminal">N</span>:<span class="ident">ident</span> : <span class="macro-nonterminal">$</span><span class="macro-nonterminal">T</span>:<span class="ident">ty</span> <span class="op">=</span> <span class="macro-nonterminal">$</span><span class="macro-nonterminal">e</span>:<span class="ident">expr</span>; $(<span class="macro-nonterminal">$</span><span class="macro-nonterminal">t</span>:<span class="ident">tt</span>)<span class="kw-2">*</span>) <span class="op">=&gt;</span> {
<span class="macro">__lazy_static_internal</span><span class="macro">!</span>(@<span class="ident">MAKE</span> <span class="ident">TY</span>, $(<span class="attribute">#[<span class="macro-nonterminal">$</span><span class="macro-nonterminal">attr</span>]</span>)<span class="kw-2">*</span>, ($(<span class="macro-nonterminal">$</span><span class="macro-nonterminal">vis</span>)<span class="kw-2">*</span>), <span class="macro-nonterminal">$</span><span class="macro-nonterminal">N</span>);
<span class="macro">__lazy_static_internal</span><span class="macro">!</span>(@<span class="ident">TAIL</span>, <span class="macro-nonterminal">$</span><span class="macro-nonterminal">N</span> : <span class="macro-nonterminal">$</span><span class="macro-nonterminal">T</span> <span class="op">=</span> <span class="macro-nonterminal">$</span><span class="macro-nonterminal">e</span>);
<span class="macro">lazy_static</span><span class="macro">!</span>($(<span class="macro-nonterminal">$</span><span class="macro-nonterminal">t</span>)<span class="kw-2">*</span>);
};
(@<span class="ident">TAIL</span>, <span class="macro-nonterminal">$</span><span class="macro-nonterminal">N</span>:<span class="ident">ident</span> : <span class="macro-nonterminal">$</span><span class="macro-nonterminal">T</span>:<span class="ident">ty</span> <span class="op">=</span> <span class="macro-nonterminal">$</span><span class="macro-nonterminal">e</span>:<span class="ident">expr</span>) <span class="op">=&gt;</span> {
<span class="kw">impl</span> <span class="macro-nonterminal">$</span><span class="kw">crate</span>::<span class="macro-nonterminal">__Deref</span> <span class="kw">for</span> <span class="macro-nonterminal">$</span><span class="macro-nonterminal">N</span> {
<span class="kw">type</span> <span class="ident">Target</span> <span class="op">=</span> <span class="macro-nonterminal">$</span><span class="macro-nonterminal">T</span>;
<span class="attribute">#[<span class="ident">allow</span>(<span class="ident">unsafe_code</span>)]</span>
<span class="kw">fn</span> <span class="ident">deref</span>(<span class="kw-2">&amp;</span><span class="self">self</span>) <span class="op">-&gt;</span> <span class="kw-2">&amp;</span><span class="macro-nonterminal">$</span><span class="macro-nonterminal">T</span> {
<span class="kw">unsafe</span> {
<span class="attribute">#[<span class="ident">inline</span>(<span class="ident">always</span>)]</span>
<span class="kw">fn</span> <span class="ident">__static_ref_initialize</span>() <span class="op">-&gt;</span> <span class="macro-nonterminal">$</span><span class="macro-nonterminal">T</span> { <span class="macro-nonterminal">$</span><span class="macro-nonterminal">e</span> }
<span class="attribute">#[<span class="ident">inline</span>(<span class="ident">always</span>)]</span>
<span class="kw">unsafe</span> <span class="kw">fn</span> <span class="ident">__stability</span>() <span class="op">-&gt;</span> <span class="kw-2">&amp;</span><span class="lifetime">&#39;static</span> <span class="macro-nonterminal">$</span><span class="macro-nonterminal">T</span> {
<span class="macro">__lazy_static_create</span><span class="macro">!</span>(<span class="ident">LAZY</span>, <span class="macro-nonterminal">$</span><span class="macro-nonterminal">T</span>);
<span class="ident">LAZY</span>.<span class="ident">get</span>(<span class="ident">__static_ref_initialize</span>)
}
<span class="ident">__stability</span>()
}
}
}
<span class="kw">impl</span> <span class="macro-nonterminal">$</span><span class="kw">crate</span>::<span class="macro-nonterminal">LazyStatic</span> <span class="kw">for</span> <span class="macro-nonterminal">$</span><span class="macro-nonterminal">N</span> {
<span class="kw">fn</span> <span class="ident">initialize</span>(<span class="ident">lazy</span>: <span class="kw-2">&amp;</span><span class="self">Self</span>) {
<span class="kw">let</span> _ <span class="op">=</span> <span class="kw-2">&amp;</span><span class="kw-2">*</span><span class="kw-2">*</span><span class="ident">lazy</span>;
}
}
};
<span class="comment">// `vis` is wrapped in `()` to prevent parsing ambiguity</span>
(@<span class="ident">MAKE</span> <span class="ident">TY</span>, $(<span class="attribute">#[<span class="macro-nonterminal">$</span><span class="macro-nonterminal">attr</span>:<span class="ident">meta</span>]</span>)<span class="kw-2">*</span>, ($(<span class="macro-nonterminal">$</span><span class="macro-nonterminal">vis</span>:<span class="ident">tt</span>)<span class="kw-2">*</span>), <span class="macro-nonterminal">$</span><span class="macro-nonterminal">N</span>:<span class="ident">ident</span>) <span class="op">=&gt;</span> {
<span class="attribute">#[<span class="ident">allow</span>(<span class="ident">missing_copy_implementations</span>)]</span>
<span class="attribute">#[<span class="ident">allow</span>(<span class="ident">non_camel_case_types</span>)]</span>
<span class="attribute">#[<span class="ident">allow</span>(<span class="ident">dead_code</span>)]</span>
$(<span class="attribute">#[<span class="macro-nonterminal">$</span><span class="macro-nonterminal">attr</span>]</span>)<span class="op">*</span>
$(<span class="macro-nonterminal">$</span><span class="macro-nonterminal">vis</span>)<span class="op">*</span> <span class="kw">struct</span> <span class="macro-nonterminal">$</span><span class="macro-nonterminal">N</span> {<span class="ident">__private_field</span>: ()}
<span class="attribute">#[<span class="ident">doc</span>(<span class="ident">hidden</span>)]</span>
$(<span class="macro-nonterminal">$</span><span class="macro-nonterminal">vis</span>)<span class="op">*</span> <span class="kw">static</span> <span class="macro-nonterminal">$</span><span class="macro-nonterminal">N</span>: <span class="macro-nonterminal">$</span><span class="macro-nonterminal">N</span> <span class="op">=</span> <span class="macro-nonterminal">$</span><span class="macro-nonterminal">N</span> {<span class="ident">__private_field</span>: ()};
};
() <span class="op">=&gt;</span> ()
}
<span class="attribute">#[<span class="ident">macro_export</span>]</span>
<span class="macro">macro_rules</span><span class="macro">!</span> <span class="ident">lazy_static</span> {
($(<span class="attribute">#[<span class="macro-nonterminal">$</span><span class="macro-nonterminal">attr</span>:<span class="ident">meta</span>]</span>)<span class="op">*</span> <span class="kw">static</span> <span class="kw-2">ref</span> <span class="macro-nonterminal">$</span><span class="macro-nonterminal">N</span>:<span class="ident">ident</span> : <span class="macro-nonterminal">$</span><span class="macro-nonterminal">T</span>:<span class="ident">ty</span> <span class="op">=</span> <span class="macro-nonterminal">$</span><span class="macro-nonterminal">e</span>:<span class="ident">expr</span>; $(<span class="macro-nonterminal">$</span><span class="macro-nonterminal">t</span>:<span class="ident">tt</span>)<span class="kw-2">*</span>) <span class="op">=&gt;</span> {
<span class="macro">lazy_static</span><span class="macro">!</span>(<span class="ident">PRIV</span>, $(<span class="attribute">#[<span class="macro-nonterminal">$</span><span class="macro-nonterminal">attr</span>]</span>)<span class="op">*</span> <span class="kw">static</span> <span class="kw-2">ref</span> <span class="macro-nonterminal">$</span><span class="macro-nonterminal">N</span> : <span class="macro-nonterminal">$</span><span class="macro-nonterminal">T</span> <span class="op">=</span> <span class="macro-nonterminal">$</span><span class="macro-nonterminal">e</span>; $(<span class="macro-nonterminal">$</span><span class="macro-nonterminal">t</span>)<span class="kw-2">*</span>);
<span class="comment">// use `()` to explicitly forward the information about private items</span>
<span class="macro">__lazy_static_internal</span><span class="macro">!</span>($(<span class="attribute">#[<span class="macro-nonterminal">$</span><span class="macro-nonterminal">attr</span>]</span>)<span class="op">*</span> () <span class="kw">static</span> <span class="kw-2">ref</span> <span class="macro-nonterminal">$</span><span class="macro-nonterminal">N</span> : <span class="macro-nonterminal">$</span><span class="macro-nonterminal">T</span> <span class="op">=</span> <span class="macro-nonterminal">$</span><span class="macro-nonterminal">e</span>; $(<span class="macro-nonterminal">$</span><span class="macro-nonterminal">t</span>)<span class="kw-2">*</span>);
};
($(<span class="attribute">#[<span class="macro-nonterminal">$</span><span class="macro-nonterminal">attr</span>:<span class="ident">meta</span>]</span>)<span class="op">*</span> <span class="kw">pub</span> <span class="kw">static</span> <span class="kw-2">ref</span> <span class="macro-nonterminal">$</span><span class="macro-nonterminal">N</span>:<span class="ident">ident</span> : <span class="macro-nonterminal">$</span><span class="macro-nonterminal">T</span>:<span class="ident">ty</span> <span class="op">=</span> <span class="macro-nonterminal">$</span><span class="macro-nonterminal">e</span>:<span class="ident">expr</span>; $(<span class="macro-nonterminal">$</span><span class="macro-nonterminal">t</span>:<span class="ident">tt</span>)<span class="kw-2">*</span>) <span class="op">=&gt;</span> {
<span class="macro">lazy_static</span><span class="macro">!</span>(<span class="ident">PUB</span>, $(<span class="attribute">#[<span class="macro-nonterminal">$</span><span class="macro-nonterminal">attr</span>]</span>)<span class="op">*</span> <span class="kw">static</span> <span class="kw-2">ref</span> <span class="macro-nonterminal">$</span><span class="macro-nonterminal">N</span> : <span class="macro-nonterminal">$</span><span class="macro-nonterminal">T</span> <span class="op">=</span> <span class="macro-nonterminal">$</span><span class="macro-nonterminal">e</span>; $(<span class="macro-nonterminal">$</span><span class="macro-nonterminal">t</span>)<span class="kw-2">*</span>);
<span class="macro">__lazy_static_internal</span><span class="macro">!</span>($(<span class="attribute">#[<span class="macro-nonterminal">$</span><span class="macro-nonterminal">attr</span>]</span>)<span class="op">*</span> (<span class="kw">pub</span>) <span class="kw">static</span> <span class="kw-2">ref</span> <span class="macro-nonterminal">$</span><span class="macro-nonterminal">N</span> : <span class="macro-nonterminal">$</span><span class="macro-nonterminal">T</span> <span class="op">=</span> <span class="macro-nonterminal">$</span><span class="macro-nonterminal">e</span>; $(<span class="macro-nonterminal">$</span><span class="macro-nonterminal">t</span>)<span class="kw-2">*</span>);
};
(<span class="macro-nonterminal">$</span><span class="macro-nonterminal">VIS</span>:<span class="ident">ident</span>, $(<span class="attribute">#[<span class="macro-nonterminal">$</span><span class="macro-nonterminal">attr</span>:<span class="ident">meta</span>]</span>)<span class="op">*</span> <span class="kw">static</span> <span class="kw-2">ref</span> <span class="macro-nonterminal">$</span><span class="macro-nonterminal">N</span>:<span class="ident">ident</span> : <span class="macro-nonterminal">$</span><span class="macro-nonterminal">T</span>:<span class="ident">ty</span> <span class="op">=</span> <span class="macro-nonterminal">$</span><span class="macro-nonterminal">e</span>:<span class="ident">expr</span>; $(<span class="macro-nonterminal">$</span><span class="macro-nonterminal">t</span>:<span class="ident">tt</span>)<span class="kw-2">*</span>) <span class="op">=&gt;</span> {
<span class="macro">lazy_static</span><span class="macro">!</span>(<span class="ident">MAKE</span> <span class="ident">TY</span>, <span class="macro-nonterminal">$</span><span class="macro-nonterminal">VIS</span>, $(<span class="attribute">#[<span class="macro-nonterminal">$</span><span class="macro-nonterminal">attr</span>]</span>)<span class="kw-2">*</span>, <span class="macro-nonterminal">$</span><span class="macro-nonterminal">N</span>);
<span class="kw">impl</span> ::<span class="ident">std</span>::<span class="ident">ops</span>::<span class="ident">Deref</span> <span class="kw">for</span> <span class="macro-nonterminal">$</span><span class="macro-nonterminal">N</span> {
<span class="kw">type</span> <span class="ident">Target</span> <span class="op">=</span> <span class="macro-nonterminal">$</span><span class="macro-nonterminal">T</span>;
<span class="kw">fn</span> <span class="ident">deref</span><span class="op">&lt;</span><span class="lifetime">&#39;a</span><span class="op">&gt;</span>(<span class="kw-2">&amp;</span><span class="lifetime">&#39;a</span> <span class="self">self</span>) <span class="op">-&gt;</span> <span class="kw-2">&amp;</span><span class="lifetime">&#39;a</span> <span class="macro-nonterminal">$</span><span class="macro-nonterminal">T</span> {
<span class="attribute">#[<span class="ident">inline</span>(<span class="ident">always</span>)]</span>
<span class="kw">fn</span> <span class="ident">__static_ref_initialize</span>() <span class="op">-&gt;</span> <span class="macro-nonterminal">$</span><span class="macro-nonterminal">T</span> { <span class="macro-nonterminal">$</span><span class="macro-nonterminal">e</span> }
<span class="kw">unsafe</span> {
<span class="kw">use</span> <span class="ident">std</span>::<span class="ident">sync</span>::{<span class="ident">Once</span>, <span class="ident">ONCE_INIT</span>};
<span class="attribute">#[<span class="ident">inline</span>(<span class="ident">always</span>)]</span>
<span class="kw">fn</span> <span class="ident">require_sync</span><span class="op">&lt;</span><span class="ident">T</span>: <span class="ident">Sync</span><span class="op">&gt;</span>(_: <span class="kw-2">&amp;</span><span class="ident">T</span>) { }
<span class="attribute">#[<span class="ident">inline</span>(<span class="ident">always</span>)]</span>
<span class="attribute">#[<span class="ident">cfg</span>(<span class="ident">feature</span><span class="op">=</span><span class="string">&quot;nightly&quot;</span>)]</span>
<span class="kw">unsafe</span> <span class="kw">fn</span> <span class="ident">__stability</span>() <span class="op">-&gt;</span> <span class="kw-2">&amp;</span><span class="lifetime">&#39;static</span> <span class="macro-nonterminal">$</span><span class="macro-nonterminal">T</span> {
<span class="kw">use</span> <span class="ident">std</span>::<span class="ident">cell</span>::<span class="ident">UnsafeCell</span>;
<span class="kw">struct</span> <span class="ident">SyncCell</span>(<span class="ident">UnsafeCell</span><span class="op">&lt;</span><span class="prelude-ty">Option</span><span class="op">&lt;</span><span class="macro-nonterminal">$</span><span class="macro-nonterminal">T</span><span class="op">&gt;&gt;</span>);
<span class="kw">unsafe</span> <span class="kw">impl</span> <span class="ident">Sync</span> <span class="kw">for</span> <span class="ident">SyncCell</span> {}
<span class="kw">static</span> <span class="ident">DATA</span>: <span class="ident">SyncCell</span> <span class="op">=</span> <span class="ident">SyncCell</span>(<span class="ident">UnsafeCell</span>::<span class="ident">new</span>(<span class="prelude-val">None</span>));
<span class="kw">static</span> <span class="ident">ONCE</span>: <span class="ident">Once</span> <span class="op">=</span> <span class="ident">ONCE_INIT</span>;
<span class="ident">ONCE</span>.<span class="ident">call_once</span>(<span class="op">||</span> {
<span class="kw-2">*</span><span class="ident">DATA</span>.<span class="number">0</span>.<span class="ident">get</span>() <span class="op">=</span> <span class="prelude-val">Some</span>(<span class="ident">__static_ref_initialize</span>());
});
<span class="kw">match</span> <span class="kw-2">*</span><span class="ident">DATA</span>.<span class="number">0</span>.<span class="ident">get</span>() {
<span class="prelude-val">Some</span>(<span class="kw-2">ref</span> <span class="ident">x</span>) <span class="op">=&gt;</span> <span class="ident">x</span>,
<span class="prelude-val">None</span> <span class="op">=&gt;</span> ::<span class="ident">std</span>::<span class="ident">intrinsics</span>::<span class="ident">unreachable</span>(),
}
}
<span class="attribute">#[<span class="ident">inline</span>(<span class="ident">always</span>)]</span>
<span class="attribute">#[<span class="ident">cfg</span>(<span class="ident">not</span>(<span class="ident">feature</span><span class="op">=</span><span class="string">&quot;nightly&quot;</span>))]</span>
<span class="kw">unsafe</span> <span class="kw">fn</span> <span class="ident">__stability</span>() <span class="op">-&gt;</span> <span class="kw-2">&amp;</span><span class="lifetime">&#39;static</span> <span class="macro-nonterminal">$</span><span class="macro-nonterminal">T</span> {
<span class="kw">use</span> <span class="ident">std</span>::<span class="ident">mem</span>::<span class="ident">transmute</span>;
<span class="kw">use</span> <span class="ident">std</span>::<span class="ident">boxed</span>::<span class="ident">Box</span>;
<span class="kw">static</span> <span class="kw-2">mut</span> <span class="ident">DATA</span>: <span class="kw-2">*</span><span class="kw">const</span> <span class="macro-nonterminal">$</span><span class="macro-nonterminal">T</span> <span class="op">=</span> <span class="number">0</span> <span class="kw">as</span> <span class="kw-2">*</span><span class="kw">const</span> <span class="macro-nonterminal">$</span><span class="macro-nonterminal">T</span>;
<span class="kw">static</span> <span class="kw-2">mut</span> <span class="ident">ONCE</span>: <span class="ident">Once</span> <span class="op">=</span> <span class="ident">ONCE_INIT</span>;
<span class="ident">ONCE</span>.<span class="ident">call_once</span>(<span class="op">||</span> {
<span class="ident">DATA</span> <span class="op">=</span> <span class="ident">transmute</span>::<span class="op">&lt;</span><span class="ident">Box</span><span class="op">&lt;</span><span class="macro-nonterminal">$</span><span class="macro-nonterminal">T</span><span class="op">&gt;</span>, <span class="kw-2">*</span><span class="kw">const</span> <span class="macro-nonterminal">$</span><span class="macro-nonterminal">T</span><span class="op">&gt;</span>(
<span class="ident">Box</span>::<span class="ident">new</span>(<span class="ident">__static_ref_initialize</span>()));
});
<span class="kw-2">&amp;</span><span class="kw-2">*</span><span class="ident">DATA</span>
}
<span class="kw">let</span> <span class="ident">static_ref</span> <span class="op">=</span> <span class="ident">__stability</span>();
<span class="ident">require_sync</span>(<span class="ident">static_ref</span>);
<span class="ident">static_ref</span>
}
}
}
<span class="macro">lazy_static</span><span class="macro">!</span>($(<span class="macro-nonterminal">$</span><span class="macro-nonterminal">t</span>)<span class="kw-2">*</span>);
};
(<span class="ident">MAKE</span> <span class="ident">TY</span>, <span class="ident">PUB</span>, $(<span class="attribute">#[<span class="macro-nonterminal">$</span><span class="macro-nonterminal">attr</span>:<span class="ident">meta</span>]</span>)<span class="kw-2">*</span>, <span class="macro-nonterminal">$</span><span class="macro-nonterminal">N</span>:<span class="ident">ident</span>) <span class="op">=&gt;</span> {
<span class="attribute">#[<span class="ident">allow</span>(<span class="ident">missing_copy_implementations</span>)]</span>
<span class="attribute">#[<span class="ident">allow</span>(<span class="ident">non_camel_case_types</span>)]</span>
<span class="attribute">#[<span class="ident">allow</span>(<span class="ident">dead_code</span>)]</span>
$(<span class="attribute">#[<span class="macro-nonterminal">$</span><span class="macro-nonterminal">attr</span>]</span>)<span class="op">*</span>
<span class="kw">pub</span> <span class="kw">struct</span> <span class="macro-nonterminal">$</span><span class="macro-nonterminal">N</span> {<span class="ident">__private_field</span>: ()}
<span class="attribute">#[<span class="ident">doc</span>(<span class="ident">hidden</span>)]</span>
<span class="kw">pub</span> <span class="kw">static</span> <span class="macro-nonterminal">$</span><span class="macro-nonterminal">N</span>: <span class="macro-nonterminal">$</span><span class="macro-nonterminal">N</span> <span class="op">=</span> <span class="macro-nonterminal">$</span><span class="macro-nonterminal">N</span> {<span class="ident">__private_field</span>: ()};
};
(<span class="ident">MAKE</span> <span class="ident">TY</span>, <span class="ident">PRIV</span>, $(<span class="attribute">#[<span class="macro-nonterminal">$</span><span class="macro-nonterminal">attr</span>:<span class="ident">meta</span>]</span>)<span class="kw-2">*</span>, <span class="macro-nonterminal">$</span><span class="macro-nonterminal">N</span>:<span class="ident">ident</span>) <span class="op">=&gt;</span> {
<span class="attribute">#[<span class="ident">allow</span>(<span class="ident">missing_copy_implementations</span>)]</span>
<span class="attribute">#[<span class="ident">allow</span>(<span class="ident">non_camel_case_types</span>)]</span>
<span class="attribute">#[<span class="ident">allow</span>(<span class="ident">dead_code</span>)]</span>
$(<span class="attribute">#[<span class="macro-nonterminal">$</span><span class="macro-nonterminal">attr</span>]</span>)<span class="op">*</span>
<span class="kw">struct</span> <span class="macro-nonterminal">$</span><span class="macro-nonterminal">N</span> {<span class="ident">__private_field</span>: ()}
<span class="attribute">#[<span class="ident">doc</span>(<span class="ident">hidden</span>)]</span>
<span class="kw">static</span> <span class="macro-nonterminal">$</span><span class="macro-nonterminal">N</span>: <span class="macro-nonterminal">$</span><span class="macro-nonterminal">N</span> <span class="op">=</span> <span class="macro-nonterminal">$</span><span class="macro-nonterminal">N</span> {<span class="ident">__private_field</span>: ()};
($(<span class="attribute">#[<span class="macro-nonterminal">$</span><span class="macro-nonterminal">attr</span>:<span class="ident">meta</span>]</span>)<span class="op">*</span> <span class="kw">pub</span> ($(<span class="macro-nonterminal">$</span><span class="macro-nonterminal">vis</span>:<span class="ident">tt</span>)<span class="op">+</span>) <span class="kw">static</span> <span class="kw-2">ref</span> <span class="macro-nonterminal">$</span><span class="macro-nonterminal">N</span>:<span class="ident">ident</span> : <span class="macro-nonterminal">$</span><span class="macro-nonterminal">T</span>:<span class="ident">ty</span> <span class="op">=</span> <span class="macro-nonterminal">$</span><span class="macro-nonterminal">e</span>:<span class="ident">expr</span>; $(<span class="macro-nonterminal">$</span><span class="macro-nonterminal">t</span>:<span class="ident">tt</span>)<span class="kw-2">*</span>) <span class="op">=&gt;</span> {
<span class="macro">__lazy_static_internal</span><span class="macro">!</span>($(<span class="attribute">#[<span class="macro-nonterminal">$</span><span class="macro-nonterminal">attr</span>]</span>)<span class="op">*</span> (<span class="kw">pub</span> ($(<span class="macro-nonterminal">$</span><span class="macro-nonterminal">vis</span>)<span class="op">+</span>)) <span class="kw">static</span> <span class="kw-2">ref</span> <span class="macro-nonterminal">$</span><span class="macro-nonterminal">N</span> : <span class="macro-nonterminal">$</span><span class="macro-nonterminal">T</span> <span class="op">=</span> <span class="macro-nonterminal">$</span><span class="macro-nonterminal">e</span>; $(<span class="macro-nonterminal">$</span><span class="macro-nonterminal">t</span>)<span class="kw-2">*</span>);
};
() <span class="op">=&gt;</span> ()
}
<span class="doccomment">/// Support trait for enabling a few common operation on lazy static values.</span>
<span class="doccomment">///</span>
<span class="doccomment">/// This is implemented by each defined lazy static, and</span>
<span class="doccomment">/// used by the free functions in this crate.</span>
<span class="kw">pub</span> <span class="kw">trait</span> <span class="ident">LazyStatic</span> {
<span class="attribute">#[<span class="ident">doc</span>(<span class="ident">hidden</span>)]</span>
<span class="kw">fn</span> <span class="ident">initialize</span>(<span class="ident">lazy</span>: <span class="kw-2">&amp;</span><span class="self">Self</span>);
}
<span class="doccomment">/// Takes a shared reference to a lazy static and initializes</span>
<span class="doccomment">/// it if it has not been already.</span>
<span class="doccomment">///</span>
<span class="doccomment">/// This can be used to control the initialization point of a lazy static.</span>
<span class="doccomment">///</span>
<span class="doccomment">/// Example:</span>
<span class="doccomment">///</span>
<span class="doccomment">/// ```rust</span>
<span class="doccomment">/// #[macro_use]</span>
<span class="doccomment">/// extern crate lazy_static;</span>
<span class="doccomment">///</span>
<span class="doccomment">/// lazy_static! {</span>
<span class="doccomment">/// static ref BUFFER: Vec&lt;u8&gt; = (0..65537).collect();</span>
<span class="doccomment">/// }</span>
<span class="doccomment">///</span>
<span class="doccomment">/// fn main() {</span>
<span class="doccomment">/// lazy_static::initialize(&amp;BUFFER);</span>
<span class="doccomment">///</span>
<span class="doccomment">/// // ...</span>
<span class="doccomment">/// work_with_initialized_data(&amp;BUFFER);</span>
<span class="doccomment">/// }</span>
<span class="doccomment">/// # fn work_with_initialized_data(_: &amp;[u8]) {}</span>
<span class="doccomment">/// ```</span>
<span class="kw">pub</span> <span class="kw">fn</span> <span class="ident">initialize</span><span class="op">&lt;</span><span class="ident">T</span>: <span class="ident">LazyStatic</span><span class="op">&gt;</span>(<span class="ident">lazy</span>: <span class="kw-2">&amp;</span><span class="ident">T</span>) {
<span class="ident">LazyStatic</span>::<span class="ident">initialize</span>(<span class="ident">lazy</span>);
}
</pre>
</section>
<section id='search' class="content hidden"></section>