code_ownership 2.1.4 → 2.2.1

data/ext/cargo-vendor/ahash-0.7.8/src/operations.rs

@@ -1,330 +0,0 @@
-use crate::convert::*;
-
-/// This is a constant with a lot of special properties found by automated search.
-/// See the unit tests below. (Below are alternative values)
-#[cfg(all(target_feature = "ssse3", not(miri)))]
-const SHUFFLE_MASK: u128 = 0x020a0700_0c01030e_050f0d08_06090b04_u128;
-//const SHUFFLE_MASK: u128 = 0x000d0702_0a040301_05080f0c_0e0b0609_u128;
-//const SHUFFLE_MASK: u128 = 0x040A0700_030E0106_0D050F08_020B0C09_u128;
-
-#[inline(always)]
-pub(crate) const fn folded_multiply(s: u64, by: u64) -> u64 {
-    let result = (s as u128).wrapping_mul(by as u128);
-    ((result & 0xffff_ffff_ffff_ffff) as u64) ^ ((result >> 64) as u64)
-}
-
-
-/// Given a small (less than 8 byte slice) returns the same data stored in two u32s.
-/// (order of and non-duplication of bytes is NOT guaranteed)
-#[inline(always)]
-pub(crate) fn read_small(data: &[u8]) -> [u64; 2] {
-    debug_assert!(data.len() <= 8);
-    if data.len() >= 2 {
-        if data.len() >= 4 {
-            //len 4-8
-            [data.read_u32().0 as u64, data.read_last_u32() as u64]
-        } else {
-            //len 2-3
-            [data.read_u16().0 as u64, data[data.len() - 1] as u64]
-        }
-    } else {
-        if data.len() > 0 {
-            [data[0] as u64, data[0] as u64]
-        } else {
-            [0, 0]
-        }
-    }
-}
-
-#[inline(always)]
-pub(crate) fn shuffle(a: u128) -> u128 {
-    #[cfg(all(target_feature = "ssse3", not(miri)))]
-    {
-        #[cfg(target_arch = "x86")]
-        use core::arch::x86::*;
-        #[cfg(target_arch = "x86_64")]
-        use core::arch::x86_64::*;
-        use core::mem::transmute;
-        unsafe { transmute(_mm_shuffle_epi8(transmute(a), transmute(SHUFFLE_MASK))) }
-    }
-    #[cfg(not(all(target_feature = "ssse3", not(miri))))]
-    {
-        a.swap_bytes()
-    }
-}
-
-#[allow(unused)] //not used by fallback
-#[inline(always)]
-pub(crate) fn add_and_shuffle(a: u128, b: u128) -> u128 {
-    let sum = add_by_64s(a.convert(), b.convert());
-    shuffle(sum.convert())
-}
-
-#[allow(unused)] //not used by fallbac
-#[inline(always)]
-pub(crate) fn shuffle_and_add(base: u128, to_add: u128) -> u128 {
-    let shuffled: [u64; 2] = shuffle(base).convert();
-    add_by_64s(shuffled, to_add.convert()).convert()
-}
-
-#[cfg(all(any(target_arch = "x86", target_arch = "x86_64"), target_feature = "sse2", not(miri)))]
-#[inline(always)]
-pub(crate) fn add_by_64s(a: [u64; 2], b: [u64; 2]) -> [u64; 2] {
-    use core::mem::transmute;
-    unsafe {
-        #[cfg(target_arch = "x86")]
-        use core::arch::x86::*;
-        #[cfg(target_arch = "x86_64")]
-        use core::arch::x86_64::*;
-        transmute(_mm_add_epi64(transmute(a), transmute(b)))
-    }
-}
-
-#[cfg(not(all(any(target_arch = "x86", target_arch = "x86_64"), target_feature = "sse2", not(miri))))]
-#[inline(always)]
-pub(crate) fn add_by_64s(a: [u64; 2], b: [u64; 2]) -> [u64; 2] {
-    [a[0].wrapping_add(b[0]), a[1].wrapping_add(b[1])]
-}
-
-#[cfg(all(any(target_arch = "x86", target_arch = "x86_64"), target_feature = "aes", not(miri)))]
-#[allow(unused)]
-#[inline(always)]
-pub(crate) fn aesenc(value: u128, xor: u128) -> u128 {
-    #[cfg(target_arch = "x86")]
-    use core::arch::x86::*;
-    #[cfg(target_arch = "x86_64")]
-    use core::arch::x86_64::*;
-    use core::mem::transmute;
-    unsafe {
-        let value = transmute(value);
-        transmute(_mm_aesenc_si128(value, transmute(xor)))
-    }
-}
-
-#[cfg(all(any(target_arch = "arm", target_arch = "aarch64"), target_feature = "crypto", not(miri), feature = "stdsimd"))]
-#[allow(unused)]
-#[inline(always)]
-pub(crate) fn aesenc(value: u128, xor: u128) -> u128 {
-    #[cfg(target_arch = "arm")]
-    use core::arch::arm::*;
-    #[cfg(target_arch = "aarch64")]
-    use core::arch::aarch64::*;
-    use core::mem::transmute;
-    unsafe {
-        let value = transmute(value);
-        transmute(vaesmcq_u8(vaeseq_u8(value, transmute(xor))))
-    }
-}
-
-#[cfg(all(any(target_arch = "x86", target_arch = "x86_64"), target_feature = "aes", not(miri)))]
-#[allow(unused)]
-#[inline(always)]
-pub(crate) fn aesdec(value: u128, xor: u128) -> u128 {
-    #[cfg(target_arch = "x86")]
-    use core::arch::x86::*;
-    #[cfg(target_arch = "x86_64")]
-    use core::arch::x86_64::*;
-    use core::mem::transmute;
-    unsafe {
-        let value = transmute(value);
-        transmute(_mm_aesdec_si128(value, transmute(xor)))
-    }
-}
-
-#[cfg(all(any(target_arch = "arm", target_arch = "aarch64"), target_feature = "crypto", not(miri), feature = "stdsimd"))]
-#[allow(unused)]
-#[inline(always)]
-pub(crate) fn aesdec(value: u128, xor: u128) -> u128 {
-    #[cfg(target_arch = "arm")]
-    use core::arch::arm::*;
-    #[cfg(target_arch = "aarch64")]
-    use core::arch::aarch64::*;
-    use core::mem::transmute;
-    unsafe {
-        let value = transmute(value);
-        transmute(vaesimcq_u8(vaesdq_u8(value, transmute(xor))))
-    }
-}
-
-#[cfg(test)]
-mod test {
-    use super::*;
-    use crate::convert::Convert;
-
-    // This is code to search for the shuffle constant
-    //
-    //thread_local! { static MASK: Cell<u128> = Cell::new(0); }
-    //
-    // fn shuffle(a: u128) -> u128 {
-    //     use std::intrinsics::transmute;
-    //     #[cfg(target_arch = "x86")]
-    //     use core::arch::x86::*;
-    //     #[cfg(target_arch = "x86_64")]
-    //     use core::arch::x86_64::*;
-    //     MASK.with(|mask| {
-    //         unsafe { transmute(_mm_shuffle_epi8(transmute(a), transmute(mask.get()))) }
-    //     })
-    // }
-    //
-    // #[test]
-    // fn find_shuffle() {
-    //     use rand::prelude::*;
-    //     use SliceRandom;
-    //     use std::panic;
-    //     use std::io::Write;
-    //
-    //     let mut value: [u8; 16] = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12 ,13, 14, 15];
-    //     let mut rand = thread_rng();
-    //     let mut successful_list = HashMap::new();
-    //     for _attempt in 0..10000000 {
-    //         rand.shuffle(&mut value);
-    //         let test_val = value.convert();
-    //         MASK.with(|mask| {
-    //             mask.set(test_val);
-    //         });
-    //         if let Ok(successful) = panic::catch_unwind(|| {
-    //             test_shuffle_does_not_collide_with_aes();
-    //             test_shuffle_moves_high_bits();
-    //             test_shuffle_moves_every_value();
-    //             //test_shuffle_does_not_loop();
-    //             value
-    //         }) {
-    //             let successful: u128 = successful.convert();
-    //             successful_list.insert(successful, iters_before_loop());
-    //         }
-    //     }
-    //     let write_file = File::create("/tmp/output").unwrap();
-    //     let mut writer = BufWriter::new(&write_file);
-    //
-    //     for success in successful_list {
-    //         writeln!(writer, "Found successful: {:x?} - {:?}", success.0, success.1);
-    //     }
-    // }
-    //
-    // fn iters_before_loop() -> u32 {
-    //     let numbered = 0x00112233_44556677_8899AABB_CCDDEEFF;
-    //     let mut shuffled = shuffle(numbered);
-    //     let mut count = 0;
-    //     loop {
-    //         // println!("{:>16x}", shuffled);
-    //         if numbered == shuffled {
-    //             break;
-    //         }
-    //         count += 1;
-    //         shuffled = shuffle(shuffled);
-    //     }
-    //     count
-    // }
-
-    #[cfg(all(
-        any(target_arch = "x86", target_arch = "x86_64"),
-        target_feature = "ssse3",
-        target_feature = "aes",
-        not(miri)
-    ))]
-    #[test]
-    fn test_shuffle_does_not_collide_with_aes() {
-        let mut value: [u8; 16] = [0; 16];
-        let zero_mask_enc = aesenc(0, 0);
-        let zero_mask_dec = aesdec(0, 0);
-        for index in 0..16 {
-            value[index] = 1;
-            let excluded_positions_enc: [u8; 16] = aesenc(value.convert(), zero_mask_enc).convert();
-            let excluded_positions_dec: [u8; 16] = aesdec(value.convert(), zero_mask_dec).convert();
-            let actual_location: [u8; 16] = shuffle(value.convert()).convert();
-            for pos in 0..16 {
-                if actual_location[pos] != 0 {
-                    assert_eq!(
-                        0, excluded_positions_enc[pos],
-                        "Forward Overlap between {:?} and {:?} at {}",
-                        excluded_positions_enc, actual_location, index
-                    );
-                    assert_eq!(
-                        0, excluded_positions_dec[pos],
-                        "Reverse Overlap between {:?} and {:?} at {}",
-                        excluded_positions_dec, actual_location, index
-                    );
-                }
-            }
-            value[index] = 0;
-        }
-    }
-
-    #[test]
-    fn test_shuffle_contains_each_value() {
-        let value: [u8; 16] = 0x00010203_04050607_08090A0B_0C0D0E0F_u128.convert();
-        let shuffled: [u8; 16] = shuffle(value.convert()).convert();
-        for index in 0..16_u8 {
-            assert!(shuffled.contains(&index), "Value is missing {}", index);
-        }
-    }
-
-    #[test]
-    fn test_shuffle_moves_every_value() {
-        let mut value: [u8; 16] = [0; 16];
-        for index in 0..16 {
-            value[index] = 1;
-            let shuffled: [u8; 16] = shuffle(value.convert()).convert();
-            assert_eq!(0, shuffled[index], "Value is not moved {}", index);
-            value[index] = 0;
-        }
-    }
-
-    #[test]
-    fn test_shuffle_moves_high_bits() {
-        assert!(
-            shuffle(1) > (1_u128 << 80),
-            "Low bits must be moved to other half {:?} -> {:?}",
-            0,
-            shuffle(1)
-        );
-
-        assert!(
-            shuffle(1_u128 << 58) >= (1_u128 << 64),
-            "High bits must be moved to other half {:?} -> {:?}",
-            7,
-            shuffle(1_u128 << 58)
-        );
-        assert!(
-            shuffle(1_u128 << 58) < (1_u128 << 112),
-            "High bits must not remain high {:?} -> {:?}",
-            7,
-            shuffle(1_u128 << 58)
-        );
-        assert!(
-            shuffle(1_u128 << 64) < (1_u128 << 64),
-            "Low bits must be moved to other half {:?} -> {:?}",
-            8,
-            shuffle(1_u128 << 64)
-        );
-        assert!(
-            shuffle(1_u128 << 64) >= (1_u128 << 16),
-            "Low bits must not remain low {:?} -> {:?}",
-            8,
-            shuffle(1_u128 << 64)
-        );
-
-        assert!(
-            shuffle(1_u128 << 120) < (1_u128 << 50),
-            "High bits must be moved to low half {:?} -> {:?}",
-            15,
-            shuffle(1_u128 << 120)
-        );
-    }
-
-    #[cfg(all(
-        any(target_arch = "x86", target_arch = "x86_64"),
-        target_feature = "ssse3",
-        not(miri)
-    ))]
-    #[test]
-    fn test_shuffle_does_not_loop() {
-        let numbered = 0x00112233_44556677_8899AABB_CCDDEEFF;
-        let mut shuffled = shuffle(numbered);
-        for count in 0..100 {
-            // println!("{:>16x}", shuffled);
-            assert_ne!(numbered, shuffled, "Equal after {} vs {:x}", count, shuffled);
-            shuffled = shuffle(shuffled);
-        }
-    }
-}

data/ext/cargo-vendor/ahash-0.7.8/src/random_state.rs

@@ -1,363 +0,0 @@
-#[cfg(all(feature = "runtime-rng", not(all(feature = "compile-time-rng", test))))]
-use crate::convert::Convert;
-#[cfg(feature = "specialize")]
-use crate::BuildHasherExt;
-
-#[cfg(any(
-    all(any(target_arch = "x86", target_arch = "x86_64"), target_feature = "aes", not(miri)),
-    all(any(target_arch = "arm", target_arch = "aarch64"), target_feature = "crypto", not(miri), feature = "stdsimd")
-))]
-pub use crate::aes_hash::*;
-
-#[cfg(not(any(
-    all(any(target_arch = "x86", target_arch = "x86_64"), target_feature = "aes", not(miri)),
-    all(any(target_arch = "arm", target_arch = "aarch64"), target_feature = "crypto", not(miri), feature = "stdsimd")
-)))]
-pub use crate::fallback_hash::*;
-
-#[cfg(all(feature = "compile-time-rng", any(not(feature = "runtime-rng"), test)))]
-use const_random::const_random;
-use core::any::{Any, TypeId};
-use core::fmt;
-use core::hash::BuildHasher;
-#[cfg(feature = "specialize")]
-use core::hash::Hash;
-use core::hash::Hasher;
-
-#[cfg(not(feature = "std"))]
-extern crate alloc;
-#[cfg(feature = "std")]
-extern crate std as alloc;
-
-#[cfg(feature = "atomic-polyfill")]
-use atomic_polyfill as atomic;
-#[cfg(not(feature = "atomic-polyfill"))]
-use core::sync::atomic;
-
-use alloc::boxed::Box;
-use atomic::{AtomicUsize, Ordering};
-#[cfg(not(all(target_arch = "arm", target_os = "none")))]
-use once_cell::race::OnceBox;
-
-#[cfg(any(
-    all(any(target_arch = "x86", target_arch = "x86_64"), target_feature = "aes", not(miri)),
-    all(any(target_arch = "arm", target_arch = "aarch64"), target_feature = "crypto", not(miri), feature = "stdsimd")
-))]
-use crate::aes_hash::*;
-#[cfg(not(any(
-    all(any(target_arch = "x86", target_arch = "x86_64"), target_feature = "aes", not(miri)),
-    all(any(target_arch = "arm", target_arch = "aarch64"), target_feature = "crypto", not(miri), feature = "stdsimd")
-)))]
-use crate::fallback_hash::*;
-
-#[cfg(not(all(target_arch = "arm", target_os = "none")))]
-static RAND_SOURCE: OnceBox<Box<dyn RandomSource + Send + Sync>> = OnceBox::new();
-
-/// A supplier of Randomness used for different hashers.
-/// See [RandomState.set_random_source].
-pub trait RandomSource {
-
-    fn get_fixed_seeds(&self) -> &'static [[u64; 4]; 2];
-
-    fn gen_hasher_seed(&self) -> usize;
-
-}
-
-pub(crate) const PI: [u64; 4] = [
-    0x243f_6a88_85a3_08d3,
-    0x1319_8a2e_0370_7344,
-    0xa409_3822_299f_31d0,
-    0x082e_fa98_ec4e_6c89,
-];
-
-pub(crate) const PI2: [u64; 4] = [
-    0x4528_21e6_38d0_1377,
-    0xbe54_66cf_34e9_0c6c,
-    0xc0ac_29b7_c97c_50dd,
-    0x3f84_d5b5_b547_0917,
-];
-
-struct DefaultRandomSource {
-    counter: AtomicUsize,
-}
-
-impl DefaultRandomSource {
-    fn new() -> DefaultRandomSource {
-        DefaultRandomSource {
-            counter: AtomicUsize::new(&PI as *const _ as usize),
-        }
-    }
-
-    const fn default() -> DefaultRandomSource {
-        DefaultRandomSource {
-            counter: AtomicUsize::new(PI[3] as usize),
-        }
-    }
-}
-
-impl RandomSource for DefaultRandomSource {
-
-    #[cfg(all(feature = "runtime-rng", not(all(feature = "compile-time-rng", test))))]
-    fn get_fixed_seeds(&self) -> &'static [[u64; 4]; 2] {
-        static SEEDS: OnceBox<[[u64; 4]; 2]> = OnceBox::new();
-
-        SEEDS.get_or_init(|| {
-            let mut result: [u8; 64] = [0; 64];
-            getrandom::getrandom(&mut result).expect("getrandom::getrandom() failed.");
-            Box::new(result.convert())
-        })
-    }
-
-    #[cfg(all(feature = "compile-time-rng", any(not(feature = "runtime-rng"), test)))]
-    fn get_fixed_seeds(&self) -> &'static [[u64; 4]; 2] {
-        const RAND: [[u64; 4]; 2] = [
-            [
-                const_random!(u64),
-                const_random!(u64),
-                const_random!(u64),
-                const_random!(u64),
-            ], [
-                const_random!(u64),
-                const_random!(u64),
-                const_random!(u64),
-                const_random!(u64),
-            ]
-        ];
-        &RAND
-    }
-
-    #[cfg(all(not(feature = "runtime-rng"), not(feature = "compile-time-rng")))]
-    fn get_fixed_seeds(&self) -> &'static [[u64; 4]; 2] {
-        &[PI, PI2]
-    }
-
-    #[cfg(not(all(target_arch = "arm", target_os = "none")))]
-    fn gen_hasher_seed(&self) -> usize {
-        let stack = self as *const _ as usize;
-        self.counter.fetch_add(stack, Ordering::Relaxed)
-    }
-
-    #[cfg(all(target_arch = "arm", target_os = "none"))]
-    fn gen_hasher_seed(&self) -> usize {
-        let stack = self as *const _ as usize;
-        let previous = self.counter.load(Ordering::Relaxed);
-        let new = previous.wrapping_add(stack);
-        self.counter.store(new, Ordering::Relaxed);
-        new
-    }
-}
-
-/// Provides a [Hasher] factory. This is typically used (e.g. by [HashMap]) to create
-/// [AHasher]s in order to hash the keys of the map. See `build_hasher` below.
-///
-/// [build_hasher]: ahash::
-/// [Hasher]: std::hash::Hasher
-/// [BuildHasher]: std::hash::BuildHasher
-/// [HashMap]: std::collections::HashMap
-#[derive(Clone)]
-pub struct RandomState {
-    pub(crate) k0: u64,
-    pub(crate) k1: u64,
-    pub(crate) k2: u64,
-    pub(crate) k3: u64,
-}
-
-impl fmt::Debug for RandomState {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        f.pad("RandomState { .. }")
-    }
-}
-
-impl RandomState {
-
-    /// Provides an optional way to manually supply a source of randomness for Hasher keys.
-    ///
-    /// The provided [RandomSource] will be used to be used as a source of randomness by [RandomState] to generate new states.
-    /// If this method is not invoked the standard source of randomness is used as described in the Readme.
-    ///
-    /// The source of randomness can only be set once, and must be set before the first RandomState is created.
-    /// If the source has already been specified `Err` is returned with a `bool` indicating if the set failed because
-    /// method was previously invoked (true) or if the default source is already being used (false).
-    #[cfg(not(all(target_arch = "arm", target_os = "none")))]
-    pub fn set_random_source(source: impl RandomSource + Send + Sync + 'static) -> Result<(), bool> {
-        RAND_SOURCE.set(Box::new(Box::new(source))).map_err(|s| s.as_ref().type_id() != TypeId::of::<&DefaultRandomSource>())
-    }
-
-    #[inline]
-    #[cfg(not(all(target_arch = "arm", target_os = "none")))]
-    fn get_src() -> &'static dyn RandomSource {
-        RAND_SOURCE.get_or_init(|| Box::new(Box::new(DefaultRandomSource::new()))).as_ref()
-    }
-
-    #[inline]
-    #[cfg(all(target_arch = "arm", target_os = "none"))]
-    fn get_src() -> &'static dyn RandomSource {
-        static RAND_SOURCE: DefaultRandomSource = DefaultRandomSource::default();
-        &RAND_SOURCE
-    }
-
-    /// Use randomly generated keys
-    #[inline]
-    pub fn new() -> RandomState {
-        let src = Self::get_src();
-        let fixed = src.get_fixed_seeds();
-        Self::from_keys(&fixed[0], &fixed[1], src.gen_hasher_seed())
-    }
-
-    /// Allows for supplying seeds, but each time it is called the resulting state will be different.
-    /// This is done using a static counter, so it can safely be used with a fixed keys.
-    #[inline]
-    pub fn generate_with(k0: u64, k1: u64, k2: u64, k3: u64) -> RandomState {
-        let src = Self::get_src();
-        let fixed = src.get_fixed_seeds();
-        RandomState::from_keys(&fixed[0], &[k0, k1, k2, k3], src.gen_hasher_seed())
-    }
-
-    fn from_keys(a: &[u64; 4], b: &[u64; 4], c: usize) -> RandomState {
-        let &[k0, k1, k2, k3] = a;
-        let mut hasher = AHasher::from_random_state(&RandomState { k0, k1, k2, k3 });
-        hasher.write_usize(c);
-        let mix = |k: u64| {
-            let mut h = hasher.clone();
-            h.write_u64(k);
-            h.finish()
-        };
-        RandomState {
-            k0: mix(b[0]),
-            k1: mix(b[1]),
-            k2: mix(b[2]),
-            k3: mix(b[3]),
-        }
-    }
-
-    /// Internal. Used by Default.
-    #[inline]
-    pub(crate) fn with_fixed_keys() -> RandomState {
-        let [k0, k1, k2, k3] = Self::get_src().get_fixed_seeds()[0];
-        RandomState { k0, k1, k2, k3 }
-    }
-
-    /// Allows for explicitly setting a seed to used.
-    ///
-    /// Note: This method does not require the provided seed to be strong.
-    #[inline]
-    pub fn with_seed(key: usize) -> RandomState {
-        let fixed = Self::get_src().get_fixed_seeds();
-        RandomState::from_keys(&fixed[0], &fixed[1], key)
-    }
-
-    /// Allows for explicitly setting the seeds to used.
-    ///
-    /// Note: This method is robust against 0s being passed for one or more of the parameters
-    /// or the same value being passed for more than one parameter.
-    #[inline]
-    pub const fn with_seeds(k0: u64, k1: u64, k2: u64, k3: u64) -> RandomState {
-        RandomState { k0: k0 ^ PI2[0], k1: k1 ^ PI2[1], k2: k2 ^ PI2[2], k3: k3 ^ PI2[3] }
-    }
-}
-
-impl Default for RandomState {
-    #[inline]
-    fn default() -> Self {
-        Self::new()
-    }
-}
-
-impl BuildHasher for RandomState {
-    type Hasher = AHasher;
-
-    /// Constructs a new [AHasher] with keys based on this [RandomState] object.
-    /// This means that two different [RandomState]s will will generate
-    /// [AHasher]s that will return different hashcodes, but [Hasher]s created from the same [BuildHasher]
-    /// will generate the same hashes for the same input data.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use ahash::{AHasher, RandomState};
-    /// use std::hash::{Hasher, BuildHasher};
-    ///
-    /// let build_hasher = RandomState::new();
-    /// let mut hasher_1 = build_hasher.build_hasher();
-    /// let mut hasher_2 = build_hasher.build_hasher();
-    ///
-    /// hasher_1.write_u32(1234);
-    /// hasher_2.write_u32(1234);
-    ///
-    /// assert_eq!(hasher_1.finish(), hasher_2.finish());
-    ///
-    /// let other_build_hasher = RandomState::new();
-    /// let mut different_hasher = other_build_hasher.build_hasher();
-    /// different_hasher.write_u32(1234);
-    /// assert_ne!(different_hasher.finish(), hasher_1.finish());
-    /// ```
-    /// [Hasher]: std::hash::Hasher
-    /// [BuildHasher]: std::hash::BuildHasher
-    /// [HashMap]: std::collections::HashMap
-    #[inline]
-    fn build_hasher(&self) -> AHasher {
-        AHasher::from_random_state(self)
-    }
-}
-
-#[cfg(feature = "specialize")]
-impl BuildHasherExt for RandomState {
-    #[inline]
-    fn hash_as_u64<T: Hash + ?Sized>(&self, value: &T) -> u64 {
-        let mut hasher = AHasherU64 {
-            buffer: self.k0,
-            pad: self.k1,
-        };
-        value.hash(&mut hasher);
-        hasher.finish()
-    }
-
-    #[inline]
-    fn hash_as_fixed_length<T: Hash + ?Sized>(&self, value: &T) -> u64 {
-        let mut hasher = AHasherFixed(self.build_hasher());
-        value.hash(&mut hasher);
-        hasher.finish()
-    }
-
-    #[inline]
-    fn hash_as_str<T: Hash + ?Sized>(&self, value: &T) -> u64 {
-        let mut hasher = AHasherStr(self.build_hasher());
-        value.hash(&mut hasher);
-        hasher.finish()
-    }
-}
-
-#[cfg(test)]
-mod test {
-    use super::*;
-
-    #[test]
-    fn test_unique() {
-        let a = RandomState::new();
-        let b = RandomState::new();
-        assert_ne!(a.build_hasher().finish(), b.build_hasher().finish());
-    }
-
-    #[cfg(all(feature = "runtime-rng", not(all(feature = "compile-time-rng", test))))]
-    #[test]
-    fn test_not_pi() {
-        assert_ne!(PI, RandomState::get_src().get_fixed_seeds()[0]);
-    }
-
-    #[cfg(all(feature = "compile-time-rng", any(not(feature = "runtime-rng"), test)))]
-    #[test]
-    fn test_not_pi_const() {
-        assert_ne!(PI, RandomState::get_src().get_fixed_seeds()[0]);
-    }
-
-    #[cfg(all(not(feature = "runtime-rng"), not(feature = "compile-time-rng")))]
-    #[test]
-    fn test_pi() {
-        assert_eq!(PI, RandomState::get_src().get_fixed_seeds()[0]);
-    }
-
-    #[test]
-    fn test_with_seeds_const() {
-        const _CONST_RANDOM_STATE: RandomState = RandomState::with_seeds(17, 19, 21, 23);
-    }
-}