Merge branch 'release/v0.2.1'

Author: flier

README.md

@@ -39,10 +39,41 @@ fn hash<T: Hash>(t: &T) -> u64 {
 hash(&"hello world");
 ```
 
+It also cowork with `HashMap` or `HashSet`, act as a hash function
+
+```rust
+use std::collections::HashSet;
+
+use fasthash::spooky::SpookyHash128;
+
+let mut set = HashSet::with_hasher(SpookyHash128 {});
+set.insert(2);
+```
+
+Or use RandomState<CityHash64> with a random seed.
+
+```rust
+use std::hash::{Hash, Hasher};
+use std::collections::HashMap;
+
+use fasthash::RandomState;
+use fasthash::city::CityHash64;
+
+let s = RandomState::<CityHash64>::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");
+```
+
 # Goal
 - High performance
 - Zero cost
-- Compatibility with [Hasher](https://doc.rust-lang.org/std/hash/trait.Hasher.html)
+- Compatibility with libstd
 
 # Features
 
@@ -56,6 +87,9 @@ hash(&"hello world");
   - [x] [Spooky Hash](http://burtleburtle.net/bob/hash/spooky.html)
   - [x] [T1 Hash](https://github.com/leo-yuriev/t1ha)
   - [x] [xx Hash](https://github.com/Cyan4973/xxHash)
+- Compatibility
+  - [x] [Hasher](https://doc.rust-lang.org/std/hash/trait.Hasher.html)
+  - [x] std::collections::{[HashMap](https://doc.rust-lang.org/std/collections/struct.HashMap.html), [HashSet](https://doc.rust-lang.org/std/collections/struct.HashSet.html)} with `RandomState`
 
 # Performance
 

fasthash-sys/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "fasthash-sys"
-version = "0.2.0"
+version = "0.2.1"
 authors = ["Flier Lu <flier.lu@gmail.com>"]
 description = "A suite of non-cryptographic hash functions for Rust."
 homepage = "https://github.com/flier/rust-fasthash"

fasthash-sys/build.rs

@@ -10,6 +10,7 @@ fn main() {
     gcc_config.file("src/fasthash.cpp")
         .file("src/smhasher/City.cpp")
         .file("src/smhasher/farmhash-c.c")
+        .file("src/smhasher/lookup3.cpp")
         .file("src/smhasher/mum.cc")
         .file("src/smhasher/metrohash64.cpp")
         .file("src/smhasher/metrohash128.cpp")
@@ -41,6 +42,7 @@ fn main() {
         .no_unstable_rust()
         .whitelisted_function("^CityHash.*")
         .whitelisted_function("^farmhash.*")
+        .whitelisted_function("^lookup3.*")
         .whitelisted_function("^metrohash.*")
         .whitelisted_function("^mum_hash.*")
         .whitelisted_function("^MurmurHash.*")

fasthash-sys/src/fasthash.hpp

@@ -13,6 +13,8 @@ uint64_t farmhash_fingerprint_uint128(uint128_c_t x);
 
 uint64_t farmhash_fingerprint_uint64(uint64_t x);
 
+uint32_t lookup3(const void * key, int length, uint32_t initval);
+
 uint64_t mum_hash_(const void *key, size_t len, uint64_t seed);
 
 void SpookyHasherHash(

fasthash/Cargo.toml

@@ -17,9 +17,9 @@ sse42 = ["fasthash-sys/sse42"]
 
 [dependencies]
 extprim = "1.1"
+rand = "^0.3"
 seahash = "3.0"
-fasthash-sys = { version = "0.2.0", path = "../fasthash-sys" }
+fasthash-sys = { version = "0.2.1", path = "../fasthash-sys" }
 
 [dev-dependencies]
-rand = "^0.3"
 fnv = "1.0"

fasthash/build.rs

@@ -24,6 +24,7 @@ fn main() {
 
     let hashes = vec![("city", vec!["CityHash32", "CityHash64", "CityHash128", "CityHashCrc128"]),
                       ("farm", vec!["FarmHash32", "FarmHash64", "FarmHash128"]),
+                      ("lookup3", vec!["Lookup3"]),
                       ("metro",
                        vec!["MetroHash64_1",
                             "MetroHash64_2",
@@ -72,6 +73,7 @@ fn bench_{name}_key_{keysize}(b: &mut Bencher) {{
                        "CityHasherExt",
                        "FarmHasher",
                        "FarmHasherExt",
+                       "Lookup3Hasher",
                        "MetroHasher",
                        "MetroHasherExt",
                        "MumHasher",

fasthash/src/city.rs

@@ -110,7 +110,7 @@
 //! use fasthash::{city, CityHasher};
 //!
 //! fn hash<T: Hash>(t: &T) -> u64 {
-//!     let mut s = CityHasher::new();
+//!     let mut s: CityHasher = Default::default();
 //!     t.hash(&mut s);
 //!     s.finish()
 //! }
@@ -126,7 +126,7 @@ use extprim::u128::u128;
 
 use ffi;
 
-use hasher::FastHash;
+use hasher::{FastHash, FastHasher};
 
 /// CityHash 32-bit hash functions
 pub struct CityHash32 {}
@@ -145,7 +145,6 @@ impl FastHash for CityHash32 {
     }
 }
 
-
 impl_hasher!(CityHasher32, CityHash32);
 
 /// CityHash 64-bit hash functions
@@ -275,13 +274,15 @@ pub fn hash64_with_seeds<T: AsRef<[u8]>>(v: &T, seed0: u64, seed1: u64) -> u64 {
 }
 
 /// CityHash 128-bit hash function for a byte array.
+#[cfg(not(feature = "sse42"))]
 #[inline]
 pub fn hash128<T: AsRef<[u8]>>(v: &T) -> u128 {
     CityHash128::hash(v)
 }
 
 /// CityHash 128-bit hash function for a byte array.
 /// For convenience, a 128-bit seed is also hashed into the result.
+#[cfg(not(feature = "sse42"))]
 #[inline]
 pub fn hash128_with_seed<T: AsRef<[u8]>>(v: &T, seed: u128) -> u128 {
     CityHash128::hash_with_seed(v, seed)
@@ -291,7 +292,7 @@ pub fn hash128_with_seed<T: AsRef<[u8]>>(v: &T, seed: u128) -> u128 {
 /// That require SSE4.2 instructions to be available.
 #[cfg(any(feature = "doc", feature = "sse42"))]
 #[inline]
-pub fn hash128crc<T: AsRef<[u8]>>(v: &T) -> u128 {
+pub fn hash128<T: AsRef<[u8]>>(v: &T) -> u128 {
     CityHashCrc128::hash(v)
 }
 
@@ -300,7 +301,7 @@ pub fn hash128crc<T: AsRef<[u8]>>(v: &T) -> u128 {
 /// That require SSE4.2 instructions to be available.
 #[cfg(any(feature = "doc", feature = "sse42"))]
 #[inline]
-pub fn hash128crc_with_seed<T: AsRef<[u8]>>(v: &T, seed: u128) -> u128 {
+pub fn hash128_with_seed<T: AsRef<[u8]>>(v: &T, seed: u128) -> u128 {
     CityHashCrc128::hash_with_seed(v, seed)
 }
 
@@ -310,7 +311,7 @@ mod tests {
 
     use extprim::u128::u128;
 
-    use hasher::{FastHash, HasherExt};
+    use hasher::{FastHash, FastHasher, HasherExt};
     use super::*;
 
     #[test]

fasthash/src/farm.rs

@@ -108,7 +108,7 @@
 //! use fasthash::{farm, FarmHasher};
 //!
 //! fn hash<T: Hash>(t: &T) -> u64 {
-//!     let mut s = FarmHasher::new();
+//!     let mut s: FarmHasher = Default::default();
 //!     t.hash(&mut s);
 //!     s.finish()
 //! }
@@ -124,7 +124,7 @@ use extprim::u128::u128;
 
 use ffi;
 
-use hasher::{Fingerprint, FastHash};
+use hasher::{Fingerprint, FastHash, FastHasher};
 
 /// FarmHash 32-bit hash functions
 pub struct FarmHash32 {}
@@ -319,7 +319,7 @@ mod tests {
 
     use extprim::u128::u128;
 
-    use hasher::{Fingerprint, FastHash, HasherExt};
+    use hasher::{Fingerprint, FastHash, FastHasher, HasherExt};
     use super::*;
 
     #[test]