1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111

//! A suite of non-cryptographic hash functions for Rust.
//!
//! # Example
//!
//! ```rust
//! use std::hash::{Hash, Hasher};
//!
//! use fasthash::{metro, MetroHasher};
//!
//! fn hash<T: Hash>(t: &T) -> u64 {
//!     let mut s: MetroHasher = Default::default();
//!     t.hash(&mut s);
//!     s.finish()
//! }
//!
//! let h = metro::hash64(b"hello world\xff");
//!
//! assert_eq!(h, hash(&"hello world"));
//! ```
//!
//! By default, `HashMap` uses a hashing algorithm selected to
//! provide resistance against `HashDoS` attacks.
//! The hashing algorithm can be replaced on a per-`HashMap` basis
//! using the `HashMap::with_hasher` or
//! `HashMap::with_capacity_and_hasher` methods.
//!
//! It also cowork with `HashMap` or `HashSet`, act as a hash function
//!
//! ```rust
//! use std::collections::HashSet;
//!
//! use fasthash::spooky::Hash128;
//!
//! let mut set = HashSet::with_hasher(Hash128);
//! set.insert(2);
//! ```
//!
//! Or use `RandomState<CityHash64>` with a random seed.
//!
//! ```rust
//! use std::collections::HashMap;
//!
//! use fasthash::{city, RandomState};
//!
//! let s = RandomState::<city::Hash64>::new();
//! let mut map = HashMap::with_hasher(s);
//!
//! assert_eq!(map.insert(37, "a"), None);
//! assert_eq!(map.is_empty(), false);
//!
//! map.insert(37, "b");
//! assert_eq!(map.insert(37, "c"), Some("b"));
//! assert_eq!(map[&37], "c");
//! ```
#![warn(missing_docs)]

#[macro_use]
extern crate cfg_if;
extern crate fasthash_sys as ffi;
extern crate num_traits;
extern crate seahash;
extern crate xoroshiro128;

#[macro_use]
mod hasher;
pub mod city;
pub mod farm;
pub mod lookup3;
pub mod metro;
pub mod mum;
pub mod murmur;
pub mod murmur2;
pub mod murmur3;
pub mod sea;
pub mod spooky;
pub mod t1ha;
pub mod xx;

pub use hasher::{
    BufHasher, FastHash, FastHasher, Fingerprint, HasherExt, RandomState, Seed, StreamHasher,
};

pub use farm::{Hasher128 as FarmHasherExt, Hasher64 as FarmHasher};
pub use lookup3::Hasher32 as Lookup3Hasher;
pub use mum::Hasher64 as MumHasher;
pub use murmur::Hasher32 as MurmurHasher;
pub use murmur3::Hasher32 as Murmur3Hasher;
#[doc(no_inline)]
pub use sea::Hasher64 as SeaHasher;
pub use spooky::{Hasher128 as SpookyHasherExt, Hasher64 as SpookyHasher};
pub use t1ha::{t1ha0, t1ha1, t1ha2};
pub use t1ha2::{Hasher128 as T1haHasherExt, Hasher64 as T1haHasher};
pub use xx::Hasher64 as XXHasher;
cfg_if! {
    if #[cfg(target_pointer_width = "64")] {
        pub use murmur2::Hasher64_x64 as Murmur2Hasher;
        pub use murmur3::Hasher128_x64 as Murmur3HasherExt;
    } else {
        pub use murmur2::Hasher64_x86 as Murmur2Hasher;
        pub use murmur3::Hasher128_x86 as Murmur3HasherExt;
    }
}
cfg_if! {
    if #[cfg(any(feature = "sse42", target_feature = "sse4.2"))] {
        pub use city::{Hasher64 as CityHasher, crc::Hasher128 as CityHasherExt};
        pub use metro::{crc::Hasher128_1 as MetroHasherExt, crc::Hasher64_1 as MetroHasher};
    } else {
        pub use city::{Hasher128 as CityHasherExt, Hasher64 as CityHasher};
        pub use metro::{Hasher128_1 as MetroHasherExt, Hasher64_1 as MetroHasher};
    }
}