hashbrown/

lib.rs

//! This crate is a Rust port of Google's high-performance [SwissTable] hash//! map, adapted to make it a drop-in replacement for Rust's standard `HashMap`//! and `HashSet` types.//!//! The original C++ version of [SwissTable] can be found [here], and this//! [CppCon talk] gives an overview of how the algorithm works.//!//! [SwissTable]: https://abseil.io/blog/20180927-swisstables//! [here]: https://github.com/abseil/abseil-cpp/blob/master/absl/container/internal/raw_hash_set.h//! [CppCon talk]: https://www.youtube.com/watch?v=ncHmEUmJZf4#![no_std]#![cfg_attr(    feature ="nightly",    feature(        test,        core_intrinsics,        dropck_eyepatch,        min_specialization,        extend_one,        allocator_api,        slice_ptr_get,        maybe_uninit_array_assume_init,        strict_provenance_lints    ))]#![cfg_attr(feature ="rustc-dep-of-std", feature(rustc_attrs))]#![allow(    clippy::doc_markdown,    clippy::module_name_repetitions,    clippy::must_use_candidate,    clippy::option_if_let_else,    clippy::redundant_else,    clippy::manual_map,    clippy::missing_safety_doc,    clippy::missing_errors_doc)]#![warn(missing_docs)]#![warn(rust_2018_idioms)]#![cfg_attr(feature ="nightly", warn(fuzzy_provenance_casts))]#![cfg_attr(    feature ="nightly",    allow(clippy::incompatible_msrv, internal_features))]#![cfg_attr(    all(feature ="nightly", target_arch ="loongarch64"),    feature(stdarch_loongarch))]#![cfg_attr(    all(feature ="nightly", feature ="default-hasher"),    feature(hasher_prefixfree_extras))]#[cfg(test)]#[macro_use]extern cratestd;#[cfg_attr(test, macro_use)]#[cfg_attr(feature ="rustc-dep-of-std", allow(unused_extern_crates))]extern cratealloc;#[cfg(feature ="nightly")]#[cfg(doctest)]doc_comment::doctest!("../README.md");#[macro_use]modmacros;modcontrol;modhasher;modraw;modutil;modexternal_trait_impls;modmap;#[cfg(feature ="raw-entry")]modraw_entry;#[cfg(feature ="rustc-internal-api")]modrustc_entry;modscopeguard;modset;modtable;pub usecrate::hasher::DefaultHashBuilder;#[cfg(feature ="default-hasher")]pub usecrate::hasher::DefaultHasher;pub modhash_map {//! A hash map implemented with quadratic probing and SIMD lookup.pub usecrate::map::*;#[cfg(feature ="rustc-internal-api")]pub usecrate::rustc_entry::*;#[cfg(feature ="rayon")]/// [rayon]-based parallel iterator types for hash maps.    /// You will rarely need to interact with it directly unless you have need    /// to name one of the iterator types.    ///    /// [rayon]: https://docs.rs/rayon/1.0/rayonpub modrayon {pub usecrate::external_trait_impls::rayon::map::*;    }}pub modhash_set {//! A hash set implemented as a `HashMap` where the value is `()`.pub usecrate::set::*;#[cfg(feature ="rayon")]/// [rayon]-based parallel iterator types for hash sets.    /// You will rarely need to interact with it directly unless you have need    /// to name one of the iterator types.    ///    /// [rayon]: https://docs.rs/rayon/1.0/rayonpub modrayon {pub usecrate::external_trait_impls::rayon::set::*;    }}pub modhash_table {//! A hash table implemented with quadratic probing and SIMD lookup.pub usecrate::table::*;#[cfg(feature ="rayon")]/// [rayon]-based parallel iterator types for hash tables.    /// You will rarely need to interact with it directly unless you have need    /// to name one of the iterator types.    ///    /// [rayon]: https://docs.rs/rayon/1.0/rayonpub modrayon {pub usecrate::external_trait_impls::rayon::table::*;    }}pub usecrate::map::HashMap;pub usecrate::set::HashSet;pub usecrate::table::HashTable;#[cfg(feature ="equivalent")]pub useequivalent::Equivalent;// This is only used as a fallback when building as part of `std`.#[cfg(not(feature ="equivalent"))]/// Key equivalence trait.////// This trait defines the function used to compare the input value with the/// map keys (or set values) during a lookup operation such as [`HashMap::get`]/// or [`HashSet::contains`]./// It is provided with a blanket implementation based on the/// [`Borrow`](core::borrow::Borrow) trait.////// # Correctness////// Equivalent values must hash to the same value.pub traitEquivalent<K:?Sized> {/// Checks if this value is equivalent to the given key.    ///    /// Returns `true` if both values are equivalent, and `false` otherwise.    ///    /// # Correctness    ///    /// When this function returns `true`, both `self` and `key` must hash to    /// the same value.fnequivalent(&self, key:&K) -> bool;}#[cfg(not(feature ="equivalent"))]impl<Q:?Sized, K:?Sized> Equivalent<K>forQwhereQ: Eq,    K: core::borrow::Borrow<Q>,{fnequivalent(&self, key:&K) -> bool {self== key.borrow()    }}/// The error type for `try_reserve` methods.#[derive(Clone, PartialEq, Eq, Debug)]pub enumTryReserveError {/// Error due to the computed capacity exceeding the collection's maximum    /// (usually `isize::MAX` bytes).CapacityOverflow,/// The memory allocator returned an errorAllocError {/// The layout of the allocation request that failed.layout:alloc::alloc::Layout,    },}