Merging upstream version 1.72.1+dfsg1.

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

6 files changed, 704 insertions, 0 deletions

diff --git a/vendor/nohash-hasher/.cargo-checksum.json b/vendor/nohash-hasher/.cargo-checksum.json
new file mode 100644
index 000000000..f1a990fcc
--- /dev/null
+++ b/vendor/nohash-hasher/.cargo-checksum.json
@@ -0,0 +1 @@
+{"files":{"Cargo.toml":"cc6743a78a5e9dca05dc2db923c8d1b3f1dfb81510d9731e4357d88f024db790","LICENSE-APACHE":"cfc7749b96f63bd31c3c42b5c471bf756814053e847c10f3eb003417bc523d30","LICENSE-MIT":"ec353d4fecf7963b4c054384557e5dbc3c7a717997eb4a3815b315721a6aa75a","README.md":"8ec67d7b36d4b99a7e254f8946d8b5f4e3ee987b80596a52cf5746819cad7940","src/lib.rs":"9dc267d4c90c83b86b47da5e58961e7ea6d4c2b659448a383293bfbc08961fa9"},"package":"2bf50223579dc7cdcfb3bfcacf7069ff68243f8c363f62ffa99cf000a6b9c451"}
\ No newline at end of file
diff --git a/vendor/nohash-hasher/Cargo.toml b/vendor/nohash-hasher/Cargo.toml
new file mode 100644
index 000000000..e065d800a
--- /dev/null
+++ b/vendor/nohash-hasher/Cargo.toml
@@ -0,0 +1,26 @@
+# THIS FILE IS AUTOMATICALLY GENERATED BY CARGO
+#
+# When uploading crates to the registry Cargo will automatically
+# "normalize" Cargo.toml files for maximal compatibility
+# with all versions of Cargo and also rewrite `path` dependencies
+# to registry (e.g., crates.io) dependencies
+#
+# If you believe there's an error in this file please file an
+# issue against the rust-lang/cargo repository. If you're
+# editing this file be aware that the upstream Cargo.toml
+# will likely look very different (and much more reasonable)
+
+[package]
+edition = "2018"
+name = "nohash-hasher"
+version = "0.2.0"
+authors = ["Parity Technologies <admin@parity.io>"]
+description = "An implementation of `std::hash::Hasher` which does not hash at all."
+readme = "README.md"
+keywords = ["hash", "hasher", "hashmap", "hashset"]
+license = "Apache-2.0 OR MIT"
+repository = "https://github.com/paritytech/nohash-hasher"
+
+[features]
+default = ["std"]
+std = []
diff --git a/vendor/nohash-hasher/LICENSE-APACHE b/vendor/nohash-hasher/LICENSE-APACHE
new file mode 100644
index 000000000..d64569567
--- /dev/null
+++ b/vendor/nohash-hasher/LICENSE-APACHE
@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
diff --git a/vendor/nohash-hasher/LICENSE-MIT b/vendor/nohash-hasher/LICENSE-MIT
new file mode 100644
index 000000000..940c8e733
--- /dev/null
+++ b/vendor/nohash-hasher/LICENSE-MIT
@@ -0,0 +1,18 @@
+Copyright 2018 Parity Technologies (UK) Ltd.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS
+OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
diff --git a/vendor/nohash-hasher/README.md b/vendor/nohash-hasher/README.md
new file mode 100644
index 000000000..5c9ac80a8
--- /dev/null
+++ b/vendor/nohash-hasher/README.md
@@ -0,0 +1,30 @@
+# NoHashHasher
+
+For an enabled type `T`, a `NoHashHasher<T>` implements `std::hash::Hasher` and
+uses the value set by one of the `write_{u8, u16, u32, u64, usize, i8, i16, i32,
+i64, isize}` methods as its hash output.
+
+`NoHashHasher` does not implement any hashing algorithm and can only be used
+with types which can be mapped directly to a numeric value. Out of the box
+`NoHashHasher` is enabled for `u8`, `u16`, `u32`, `u64`, `usize`, `i8`, `i16`,
+`i32`, `i64`, and `isize`. Types that should be used with `NoHashHasher` need
+to implement [`IsEnabled`] and by doing so assert that their `Hash` impl invokes
+*only one* of the `Hasher::write_{u8, u16, u32, u64, usize, i8, i16, i32, i64,
+isize}` methods *exactly once*.
+
+## License
+
+Licensed under either of
+
+ * Apache License, Version 2.0
+   ([LICENSE-APACHE](LICENSE-APACHE) or http://www.apache.org/licenses/LICENSE-2.0)
+ * MIT license
+   ([LICENSE-MIT](LICENSE-MIT) or http://opensource.org/licenses/MIT)
+
+at your option.
+
+## Contribution
+
+Unless you explicitly state otherwise, any contribution intentionally submitted
+for inclusion in the work by you, as defined in the Apache-2.0 license, shall be
+dual licensed as above, without any additional terms or conditions.
diff --git a/vendor/nohash-hasher/src/lib.rs b/vendor/nohash-hasher/src/lib.rs
new file mode 100644
index 000000000..50e024ef7
--- /dev/null
+++ b/vendor/nohash-hasher/src/lib.rs
@@ -0,0 +1,427 @@
+// Copyright 2018-2020 Parity Technologies (UK) Ltd.
+//
+// Licensed under the Apache License, Version 2.0 or MIT license, at your option.
+//
+// A copy of the Apache License, Version 2.0 is included in the software as
+// LICENSE-APACHE and a copy of the MIT license is included in the software
+// as LICENSE-MIT. You may also obtain a copy of the Apache License, Version 2.0
+// at https://www.apache.org/licenses/LICENSE-2.0 and a copy of the MIT license
+// at https://opensource.org/licenses/MIT.
+
+#![cfg_attr(not(feature = "std"), no_std)]
+
+use core::{fmt, hash::{BuildHasherDefault, Hasher}, marker::PhantomData};
+
+/// A `HashMap` with an integer domain, using `NoHashHasher` to perform no hashing at all.
+///
+/// # Examples
+///
+/// See [`IsEnabled`] for use with custom types.
+///
+/// ```
+/// use nohash_hasher::IntMap;
+///
+/// let mut m: IntMap<u32, bool> = IntMap::default();
+///
+/// m.insert(0, false);
+/// m.insert(1, true);
+///
+/// assert!(m.contains_key(&0));
+/// assert!(m.contains_key(&1));
+/// ```
+#[cfg(feature = "std")]
+pub type IntMap<K, V> = std::collections::HashMap<K, V, BuildNoHashHasher<K>>;
+
+/// A `HashSet` of integers, using `NoHashHasher` to perform no hashing at all.
+///
+/// # Examples
+///
+/// See [`IsEnabled`] for use with custom types.
+///
+/// ```
+/// use nohash_hasher::IntSet;
+///
+/// let mut m = IntSet::default();
+///
+/// m.insert(0u32);
+/// m.insert(1u32);
+///
+/// assert!(m.contains(&0));
+/// assert!(m.contains(&1));
+/// ```
+#[cfg(feature = "std")]
+pub type IntSet<T> = std::collections::HashSet<T, BuildNoHashHasher<T>>;
+
+/// An alias for `BuildHasherDefault` for use with `NoHashHasher`.
+///
+/// # Examples
+///
+/// See also [`IntMap`] and [`IntSet`] for some easier usage examples.
+///
+/// ```
+/// use nohash_hasher::BuildNoHashHasher;
+/// use std::collections::HashMap;
+///
+/// let mut m: HashMap::<u8, char, BuildNoHashHasher<u8>> =
+///     HashMap::with_capacity_and_hasher(2, BuildNoHashHasher::default());
+///
+/// m.insert(0, 'a');
+/// m.insert(1, 'b');
+///
+/// assert_eq!(Some(&'a'), m.get(&0));
+/// assert_eq!(Some(&'b'), m.get(&1));
+/// ```
+pub type BuildNoHashHasher<T> = BuildHasherDefault<NoHashHasher<T>>;
+
+/// For an enabled type `T`, a `NoHashHasher<T>` implements `std::hash::Hasher` and
+/// uses the value set by one of the `write_{u8, u16, u32, u64, usize, i8, i16, i32,
+/// i64, isize}` methods as its hash output.
+///
+/// `NoHashHasher` does not implement any hashing algorithm and can only be used
+/// with types which can be mapped directly to a numeric value. Out of the box
+/// `NoHashHasher` is enabled for `u8`, `u16`, `u32`, `u64`, `usize`, `i8`, `i16`,
+/// `i32`, `i64`, and `isize`. Types that should be used with `NoHashHasher` need
+/// to implement [`IsEnabled`] and by doing so assert that their `Hash` impl invokes
+/// *only one* of the `Hasher::write_{u8, u16, u32, u64, usize, i8, i16, i32, i64,
+/// isize}` methods *exactly once*.
+///
+/// # Examples
+///
+/// See also [`BuildNoHashHasher`], [`IntMap`] and [`IntSet`] for some easier
+/// usage examples. See [`IsEnabled`] for use with custom types.
+///
+/// ```
+/// use nohash_hasher::NoHashHasher;
+/// use std::{collections::HashMap, hash::BuildHasherDefault};
+///
+/// let mut m: HashMap::<u8, char, BuildHasherDefault<NoHashHasher<u8>>> =
+///     HashMap::with_capacity_and_hasher(2, BuildHasherDefault::default());
+///
+/// m.insert(0, 'a');
+/// m.insert(1, 'b');
+///
+/// assert_eq!(Some(&'a'), m.get(&0));
+/// assert_eq!(Some(&'b'), m.get(&1));
+/// ```
+#[cfg(debug_assertions)]
+pub struct NoHashHasher<T>(u64, bool, PhantomData<T>);
+
+#[cfg(not(debug_assertions))]
+pub struct NoHashHasher<T>(u64, PhantomData<T>);
+
+impl<T> fmt::Debug for NoHashHasher<T> {
+    #[cfg(debug_assertions)]
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        f.debug_tuple("NoHashHasher").field(&self.0).field(&self.1).finish()
+    }
+
+    #[cfg(not(debug_assertions))]
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        f.debug_tuple("NoHashHasher").field(&self.0).finish()
+    }
+}
+
+impl<T> Default for NoHashHasher<T> {
+    #[cfg(debug_assertions)]
+    fn default() -> Self {
+        NoHashHasher(0, false, PhantomData)
+    }
+
+    #[cfg(not(debug_assertions))]
+    fn default() -> Self {
+        NoHashHasher(0, PhantomData)
+    }
+}
+
+impl<T> Clone for NoHashHasher<T> {
+    #[cfg(debug_assertions)]
+    fn clone(&self) -> Self {
+        NoHashHasher(self.0, self.1, self.2)
+    }
+
+    #[cfg(not(debug_assertions))]
+    fn clone(&self) -> Self {
+        NoHashHasher(self.0, self.1)
+    }
+}
+
+impl<T> Copy for NoHashHasher<T> {}
+
+/// Types which are safe to use with `NoHashHasher`.
+///
+/// This marker trait is an option for types to enable themselves for use
+/// with `NoHashHasher`. In order to be safe, the `Hash` impl needs to
+/// satisfy the following constraint:
+///
+/// > **One of the `Hasher::write_{u8,u16,u32,u64,usize,i8,i16,i32,i64,isize}`
+/// methods is invoked exactly once.**
+///
+/// The best way to ensure this is to write a custom `Hash` impl even when
+/// deriving `Hash` for a simple newtype of a single type which itself
+/// implements `IsEnabled` may work as well.
+///
+/// # Example
+///
+/// ```
+/// #[derive(PartialEq, Eq)]
+/// struct SomeType(u32);
+///
+/// impl std::hash::Hash for SomeType {
+///     fn hash<H: std::hash::Hasher>(&self, hasher: &mut H) {
+///         hasher.write_u32(self.0)
+///     }
+/// }
+///
+/// impl nohash_hasher::IsEnabled for SomeType {}
+///
+/// let mut m = nohash_hasher::IntMap::default();
+///
+/// m.insert(SomeType(1), 't');
+/// m.insert(SomeType(0), 'f');
+///
+/// assert_eq!(Some(&'t'), m.get(&SomeType(1)));
+/// assert_eq!(Some(&'f'), m.get(&SomeType(0)));
+/// ```
+pub trait IsEnabled {}
+
+impl IsEnabled for u8 {}
+impl IsEnabled for u16 {}
+impl IsEnabled for u32 {}
+impl IsEnabled for u64 {}
+impl IsEnabled for usize {}
+impl IsEnabled for i8 {}
+impl IsEnabled for i16 {}
+impl IsEnabled for i32 {}
+impl IsEnabled for i64 {}
+impl IsEnabled for isize {}
+
+#[cfg(not(debug_assertions))]
+impl<T: IsEnabled> Hasher for NoHashHasher<T> {
+    fn write(&mut self, _: &[u8]) {
+        panic!("Invalid use of NoHashHasher")
+    }
+
+    fn write_u8(&mut self, n: u8)       { self.0 = u64::from(n) }
+    fn write_u16(&mut self, n: u16)     { self.0 = u64::from(n) }
+    fn write_u32(&mut self, n: u32)     { self.0 = u64::from(n) }
+    fn write_u64(&mut self, n: u64)     { self.0 = n }
+    fn write_usize(&mut self, n: usize) { self.0 = n as u64 }
+
+    fn write_i8(&mut self, n: i8)       { self.0 = n as u64 }
+    fn write_i16(&mut self, n: i16)     { self.0 = n as u64 }
+    fn write_i32(&mut self, n: i32)     { self.0 = n as u64 }
+    fn write_i64(&mut self, n: i64)     { self.0 = n as u64 }
+    fn write_isize(&mut self, n: isize) { self.0 = n as u64 }
+
+    fn finish(&self) -> u64 { self.0 }
+}
+
+#[cfg(debug_assertions)]
+impl<T: IsEnabled> Hasher for NoHashHasher<T> {
+    fn write(&mut self, _: &[u8]) {
+        panic!("Invalid use of NoHashHasher")
+    }
+
+    fn write_u8(&mut self, n: u8) {
+        assert!(!self.1, "NoHashHasher: second write attempt detected.");
+        self.0 = u64::from(n);
+        self.1 = true
+    }
+
+    fn write_u16(&mut self, n: u16) {
+        assert!(!self.1, "NoHashHasher: second write attempt detected.");
+        self.0 = u64::from(n);
+        self.1 = true
+    }
+
+    fn write_u32(&mut self, n: u32) {
+        assert!(!self.1, "NoHashHasher: second write attempt detected.");
+        self.0 = u64::from(n);
+        self.1 = true
+    }
+
+    fn write_u64(&mut self, n: u64) {
+        assert!(!self.1, "NoHashHasher: second write attempt detected.");
+        self.0 = n;
+        self.1 = true
+    }
+
+    fn write_usize(&mut self, n: usize) {
+        assert!(!self.1, "NoHashHasher: second write attempt detected.");
+        self.0 = n as u64;
+        self.1 = true
+    }
+
+    fn write_i8(&mut self, n: i8) {
+        assert!(!self.1, "NoHashHasher: second write attempt detected.");
+        self.0 = n as u64;
+        self.1 = true
+    }
+
+    fn write_i16(&mut self, n: i16) {
+        assert!(!self.1, "NoHashHasher: second write attempt detected.");
+        self.0 = n as u64;
+        self.1 = true
+    }
+
+    fn write_i32(&mut self, n: i32) {
+        assert!(!self.1, "NoHashHasher: second write attempt detected.");
+        self.0 = n as u64;
+        self.1 = true
+    }
+
+    fn write_i64(&mut self, n: i64) {
+        assert!(!self.1, "NoHashHasher: second write attempt detected.");
+        self.0 = n as u64;
+        self.1 = true
+    }
+
+    fn write_isize(&mut self, n: isize) {
+        assert!(!self.1, "NoHashHasher: second write attempt detected.");
+        self.0 = n as u64;
+        self.1 = true
+    }
+
+    fn finish(&self) -> u64 {
+        self.0
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn ok() {
+        let mut h1 = NoHashHasher::<u8>::default();
+        h1.write_u8(42);
+        assert_eq!(42, h1.finish());
+
+        let mut h2 = NoHashHasher::<u16>::default();
+        h2.write_u16(42);
+        assert_eq!(42, h2.finish());
+
+        let mut h3 = NoHashHasher::<u32>::default();
+        h3.write_u32(42);
+        assert_eq!(42, h3.finish());
+
+        let mut h4 = NoHashHasher::<u64>::default();
+        h4.write_u64(42);
+        assert_eq!(42, h4.finish());
+
+        let mut h5 = NoHashHasher::<usize>::default();
+        h5.write_usize(42);
+        assert_eq!(42, h5.finish());
+
+        let mut h6 = NoHashHasher::<i8>::default();
+        h6.write_i8(42);
+        assert_eq!(42, h6.finish());
+
+        let mut h7 = NoHashHasher::<i16>::default();
+        h7.write_i16(42);
+        assert_eq!(42, h7.finish());
+
+        let mut h8 = NoHashHasher::<i32>::default();
+        h8.write_i32(42);
+        assert_eq!(42, h8.finish());
+
+        let mut h9 = NoHashHasher::<i64>::default();
+        h9.write_i64(42);
+        assert_eq!(42, h9.finish());
+
+        let mut h10 = NoHashHasher::<isize>::default();
+        h10.write_isize(42);
+        assert_eq!(42, h10.finish())
+    }
+
+    #[cfg(debug_assertions)]
+    #[test]
+    #[should_panic]
+    fn u8_double_usage() {
+        let mut h = NoHashHasher::<u8>::default();
+        h.write_u8(42);
+        h.write_u8(43);
+    }
+
+    #[cfg(debug_assertions)]
+    #[test]
+    #[should_panic]
+    fn u16_double_usage() {
+        let mut h = NoHashHasher::<u16>::default();
+        h.write_u16(42);
+        h.write_u16(43);
+    }
+
+    #[cfg(debug_assertions)]
+    #[test]
+    #[should_panic]
+    fn u32_double_usage() {
+        let mut h = NoHashHasher::<u32>::default();
+        h.write_u32(42);
+        h.write_u32(43);
+    }
+
+    #[cfg(debug_assertions)]
+    #[test]
+    #[should_panic]
+    fn u64_double_usage() {
+        let mut h = NoHashHasher::<u64>::default();
+        h.write_u64(42);
+        h.write_u64(43);
+    }
+
+    #[cfg(debug_assertions)]
+    #[test]
+    #[should_panic]
+    fn usize_double_usage() {
+        let mut h = NoHashHasher::<usize>::default();
+        h.write_usize(42);
+        h.write_usize(43);
+    }
+
+    #[cfg(debug_assertions)]
+    #[test]
+    #[should_panic]
+    fn i8_double_usage() {
+        let mut h = NoHashHasher::<i8>::default();
+        h.write_i8(42);
+        h.write_i8(43);
+    }
+
+    #[cfg(debug_assertions)]
+    #[test]
+    #[should_panic]
+    fn i16_double_usage() {
+        let mut h = NoHashHasher::<i16>::default();
+        h.write_i16(42);
+        h.write_i16(43);
+    }
+
+    #[cfg(debug_assertions)]
+    #[test]
+    #[should_panic]
+    fn i32_double_usage() {
+        let mut h = NoHashHasher::<i32>::default();
+        h.write_i32(42);
+        h.write_i32(43);
+    }
+
+    #[cfg(debug_assertions)]
+    #[test]
+    #[should_panic]
+    fn i64_double_usage() {
+        let mut h = NoHashHasher::<i64>::default();
+        h.write_i64(42);
+        h.write_i64(43);
+    }
+
+    #[cfg(debug_assertions)]
+    #[test]
+    #[should_panic]
+    fn isize_double_usage() {
+        let mut h = NoHashHasher::<isize>::default();
+        h.write_isize(42);
+        h.write_isize(43);
+    }
+}
+