(automated) deploy from commit d920f19

src/wiwi/_internal/encoding_utils.rs.html

@@ -372,7 +372,7 @@
 	/// memory, it gives us at least that much, then we are not touching it, until
 	/// `self` gets unwrapped using [`into_full_vec`](Self::into_full_vec). After
 	/// that, we will never use this pointer again. We are then (unsafely) setting
-	/// the len of the vec to the requested amount of capacity initially, which
+	/// the len of the vec to the initially requested amount of capacity, which
 	/// the caller of that method promises is initialised, since it is a safety
 	/// invariant of [`into_full_vec`]. What happens to the vec after we hand it's
 	/// ownership back to caller, is no longer on us to handle. The pointer has

src/wiwi/clock_timer/mod.rs.html

@@ -220,11 +220,7 @@
 <a href="#220" id="220">220</a>
 <a href="#221" id="221">221</a>
 <a href="#222" id="222">222</a>
-<a href="#223" id="223">223</a>
-<a href="#224" id="224">224</a>
-</pre></div><pre class="rust"><code><span class="doccomment">//! An interval tracking clock
-
-</span><span class="kw">pub use </span>chrono;
+</pre></div><pre class="rust"><code><span class="kw">pub use </span>chrono;
 
 <span class="kw">use </span>chrono::{ DateTime, Local, NaiveDateTime, TimeDelta, Timelike, TimeZone };
 <span class="kw">use </span>std::future::Future;

src/wiwi/debounce/mod.rs.html

@@ -174,13 +174,7 @@
 <a href="#174" id="174">174</a>
 <a href="#175" id="175">175</a>
 <a href="#176" id="176">176</a>
-<a href="#177" id="177">177</a>
-<a href="#178" id="178">178</a>
-<a href="#179" id="179">179</a>
-</pre></div><pre class="rust"><code><span class="doccomment">//! A debounced function; or a function that won't actually get called until
-//! there haven't been calls to it for a certain amount of time.
-
-</span><span class="kw">use </span><span class="kw">crate</span>::num_traits::<span class="kw-2">*</span>;
+</pre></div><pre class="rust"><code><span class="kw">use </span><span class="kw">crate</span>::num_traits::<span class="kw-2">*</span>;
 <span class="kw">use </span>chrono::{ Local, NaiveDateTime, TimeDelta };
 <span class="kw">use </span>std::{ mem::swap, sync::Arc };
 <span class="kw">use </span>tokio::runtime::Handle;

src/wiwi/defer/mod.rs.html

@@ -577,6 +577,8 @@
 <a href="#577" id="577">577</a>
 <a href="#578" id="578">578</a>
 <a href="#579" id="579">579</a>
+<a href="#580" id="580">580</a>
+<a href="#581" id="581">581</a>
 </pre></div><pre class="rust"><code><span class="kw">use </span>std::fmt::{ <span class="self">self</span>, Debug, Display };
 <span class="kw">use </span>std::mem::ManuallyDrop;
 <span class="kw">use </span>std::ops::{ Deref, DerefMut };
@@ -1077,7 +1079,9 @@
 
 <span class="attr">#[cfg(test)]
 </span><span class="kw">mod </span>tests {
-	<span class="kw">use super</span>::<span class="kw-2">*</span>;
+	<span class="comment">// TODO: need to do something about the way these test are run, since
+	// assert/etc panic and we catch_unwind sometimes, so that's, hmmm
+	</span><span class="kw">use super</span>::<span class="kw-2">*</span>;
 	<span class="kw">use </span>std::cell::Cell;
 	<span class="kw">use </span>std::panic::{ AssertUnwindSafe, catch_unwind };
 

src/wiwi/h/mod.rs.html

@@ -26,11 +26,7 @@
 <a href="#26" id="26">26</a>
 <a href="#27" id="27">27</a>
 <a href="#28" id="28">28</a>
-<a href="#29" id="29">29</a>
-<a href="#30" id="30">30</a>
-</pre></div><pre class="rust"><code><span class="doccomment">//! h
-
-/// h
+</pre></div><pre class="rust"><code><span class="doccomment">/// h
 </span><span class="attr">#[inline]
 </span><span class="kw">pub fn </span>h() -&gt; String {
 	<span class="string">"h"</span>.into()

src/wiwi/hex/decode.rs.html

@@ -155,7 +155,7 @@
 				// ie. within range to index table ptr
 				</span><span class="kw">let </span>ptr = <span class="kw">unsafe </span>{ table_ptr.add(<span class="macro-nonterminal">$byte</span>) };
 
-				<span class="comment">// SAFETY: as describe above, ptr is valid to read
+				<span class="comment">// SAFETY: as described above, ptr is valid to read
 				</span><span class="kw">let </span><span class="macro-nonterminal">$byte </span>= <span class="kw">unsafe </span>{ <span class="kw-2">*</span>ptr };
 
 				<span class="kw">let </span><span class="macro-nonterminal">$byte </span>= <span class="kw">match </span><span class="macro-nonterminal">$byte </span>{

src/wiwi/hex/mod.rs.html

@@ -187,11 +187,7 @@
 <a href="#187" id="187">187</a>
 <a href="#188" id="188">188</a>
 <a href="#189" id="189">189</a>
-<a href="#190" id="190">190</a>
-<a href="#191" id="191">191</a>
-</pre></div><pre class="rust"><code><span class="doccomment">//! Fast and efficient implementation of hex encoding.
-
-</span><span class="kw">use </span><span class="kw">crate</span>::_internal::encoding_utils::UnsafeBufWriteGuard;
+</pre></div><pre class="rust"><code><span class="kw">use </span><span class="kw">crate</span>::_internal::encoding_utils::UnsafeBufWriteGuard;
 <span class="kw">use </span>std::str;
 
 <span class="doccomment">/// Length of encoding table (not actually used in encoding/decoding data)

src/wiwi/id/mod.rs.html

@@ -262,6 +262,7 @@
 <a href="#262" id="262">262</a>
 <a href="#263" id="263">263</a>
 <a href="#264" id="264">264</a>
+<a href="#265" id="265">265</a>
 </pre></div><pre class="rust"><code><span class="kw">use </span><span class="kw">crate</span>::num_traits::<span class="kw-2">*</span>;
 <span class="kw">use </span><span class="kw">crate</span>::rand::ThreadLocalChaCha8Rng;
 <span class="kw">use </span>std::time::{ SystemTime, UNIX_EPOCH };
@@ -283,7 +284,8 @@
 </span><span class="kw">const </span>RANDOM_COMPONENT_MASK: u8 = <span class="number">0b1111</span>;
 
 <span class="doccomment">/// When storing as an signed int, we flip the top bit (two's complement), so
-/// sorting numerically by this signed int representation of the ID will still work.
+/// sorting numerically by this signed int representation of the ID will still
+/// work the same.
 </span><span class="kw">const </span>TOP_BIT: u64 = <span class="number">1 </span>&lt;&lt; (u64::BITS - <span class="number">1</span>);
 
 <span class="doccomment">/// counting from the most significant to least significant bit, bits 1 to 64:
@@ -293,8 +295,8 @@
 /// - (47-60) 14 bits for increment (this is max 16384 IDs/ms, or about 16M IDs/s)
 /// - (61-64) last 4 bits for randomness (so IDs within one ms aren't just increments)
 ///
-/// IDs generated from one single factory are guaranteed to be unique and
-/// monotonically increase.
+/// IDs generated from one single instance of this generator are guaranteed to
+/// be unique and monotonically increasing.
 </span><span class="kw">pub struct </span>IDGenerator {
 	<span class="doccomment">/// unix epoch time
 	</span>last_generated_time: u64,

src/wiwi/lazy_wrap/mod.rs.html

@@ -243,15 +243,7 @@
 <a href="#243" id="243">243</a>
 <a href="#244" id="244">244</a>
 <a href="#245" id="245">245</a>
-<a href="#246" id="246">246</a>
-<a href="#247" id="247">247</a>
-<a href="#248" id="248">248</a>
-<a href="#249" id="249">249</a>
-</pre></div><pre class="rust"><code><span class="doccomment">//! Wrapper for initialisation function, initialising it only on first access.
-//!
-//! Works in static contexts (static variables)
-
-</span><span class="kw">use </span>parking_lot::{ Once, OnceState };
+</pre></div><pre class="rust"><code><span class="kw">use </span>parking_lot::{ Once, OnceState };
 <span class="kw">use </span>std::cell::UnsafeCell;
 <span class="kw">use </span>std::fmt::{ <span class="self">self</span>, Debug, Display };
 <span class="kw">use </span>std::mem::ManuallyDrop;