/*
- * Copyright 2015 Facebook, Inc.
+ * Copyright 2017 Facebook, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* limitations under the License.
*/
-#ifndef FOLLY_BASE_HASH_H_
-#define FOLLY_BASE_HASH_H_
+#pragma once
#include <cstdint>
#include <cstring>
+#include <limits>
#include <string>
#include <tuple>
#include <type_traits>
#include <utility>
-#include <folly/ApplyTuple.h>
#include <folly/Bits.h>
-#include <folly/SpookyHashV1.h>
-#include <folly/SpookyHashV2.h>
+#include <folly/functional/ApplyTuple.h>
+#include <folly/hash/SpookyHashV1.h>
+#include <folly/hash/SpookyHashV2.h>
/*
* Various hashing functions.
const uint32_t FNV_32_HASH_START = 2166136261UL;
const uint64_t FNV_64_HASH_START = 14695981039346656037ULL;
+const uint64_t FNVA_64_HASH_START = 14695981039346656037ULL;
+
+inline uint32_t fnv32(const char* buf, uint32_t hash = FNV_32_HASH_START) {
+ // forcing signed char, since other platforms can use unsigned
+ const signed char* s = reinterpret_cast<const signed char*>(buf);
-inline uint32_t fnv32(const char* s,
- uint32_t hash = FNV_32_HASH_START) {
for (; *s; ++s) {
hash += (hash << 1) + (hash << 4) + (hash << 7) +
(hash << 8) + (hash << 24);
return fnv32_buf(str.data(), str.size(), hash);
}
-inline uint64_t fnv64(const char* s,
- uint64_t hash = FNV_64_HASH_START) {
+inline uint64_t fnv64(const char* buf, uint64_t hash = FNV_64_HASH_START) {
+ // forcing signed char, since other platforms can use unsigned
+ const signed char* s = reinterpret_cast<const signed char*>(buf);
+
for (; *s; ++s) {
hash += (hash << 1) + (hash << 4) + (hash << 5) + (hash << 7) +
(hash << 8) + (hash << 40);
return fnv64_buf(str.data(), str.size(), hash);
}
+inline uint64_t fnva64_buf(const void* buf,
+ size_t n,
+ uint64_t hash = FNVA_64_HASH_START) {
+ const uint8_t* char_buf = reinterpret_cast<const uint8_t*>(buf);
+
+ for (size_t i = 0; i < n; ++i) {
+ hash ^= char_buf[i];
+ hash += (hash << 1) + (hash << 4) + (hash << 5) + (hash << 7) +
+ (hash << 8) + (hash << 40);
+ }
+ return hash;
+}
+
+inline uint64_t fnva64(const std::string& str,
+ uint64_t hash = FNVA_64_HASH_START) {
+ return fnva64_buf(str.data(), str.size(), hash);
+}
+
/*
* Paul Hsieh: http://www.azillionmonkeys.com/qed/hash.html
*/
inline uint32_t hsieh_hash32_buf(const void* buf, size_t len) {
// forcing signed char, since other platforms can use unsigned
- const signed char* s = reinterpret_cast<const signed char*>(buf);
+ const unsigned char* s = reinterpret_cast<const unsigned char*>(buf);
uint32_t hash = static_cast<uint32_t>(len);
uint32_t tmp;
size_t rem;
- if (len <= 0 || buf == 0) {
+ if (len <= 0 || buf == nullptr) {
return 0;
}
} // namespace hash
-template<class Key, class Enable = void>
+namespace detail {
+struct integral_hasher {
+ template <typename I>
+ size_t operator()(I const& i) const {
+ static_assert(sizeof(I) <= 8, "input type is too wide");
+ if (sizeof(I) <= 4) { // the branch taken is known at compile time
+ auto const i32 = static_cast<int32_t>(i); // impl accident: sign-extends
+ auto const u32 = static_cast<uint32_t>(i32);
+ return static_cast<size_t>(hash::jenkins_rev_mix32(u32));
+ } else {
+ auto const u64 = static_cast<uint64_t>(i);
+ return static_cast<size_t>(hash::twang_mix64(u64));
+ }
+ }
+};
+} // namespace detail
+
+template <class Key, class Enable = void>
struct hasher;
struct Hash {
}
};
-template<> struct hasher<int32_t> {
- size_t operator()(int32_t key) const {
- return hash::jenkins_rev_mix32(uint32_t(key));
+template <>
+struct hasher<bool> {
+ size_t operator()(bool key) const {
+ // Make sure that all the output bits depend on the input.
+ return key ? std::numeric_limits<size_t>::max() : 0;
}
};
-template<> struct hasher<uint32_t> {
- size_t operator()(uint32_t key) const {
- return hash::jenkins_rev_mix32(key);
- }
-};
+template <>
+struct hasher<unsigned long long> : detail::integral_hasher {};
-template<> struct hasher<int64_t> {
- size_t operator()(int64_t key) const {
- return static_cast<size_t>(hash::twang_mix64(uint64_t(key)));
- }
-};
+template <>
+struct hasher<signed long long> : detail::integral_hasher {};
-template<> struct hasher<uint64_t> {
- size_t operator()(uint64_t key) const {
- return static_cast<size_t>(hash::twang_mix64(key));
- }
-};
+template <>
+struct hasher<unsigned long> : detail::integral_hasher {};
-template<> struct hasher<std::string> {
+template <>
+struct hasher<signed long> : detail::integral_hasher {};
+
+template <>
+struct hasher<unsigned int> : detail::integral_hasher {};
+
+template <>
+struct hasher<signed int> : detail::integral_hasher {};
+
+template <>
+struct hasher<unsigned short> : detail::integral_hasher {};
+
+template <>
+struct hasher<signed short> : detail::integral_hasher {};
+
+template <>
+struct hasher<unsigned char> : detail::integral_hasher {};
+
+template <>
+struct hasher<signed char> : detail::integral_hasher {};
+
+template <> // char is a different type from both signed char and unsigned char
+struct hasher<char> : detail::integral_hasher {};
+
+template <> struct hasher<std::string> {
size_t operator()(const std::string& key) const {
return static_cast<size_t>(
hash::SpookyHashV2::Hash64(key.data(), key.size(), 0));
// items in the pair.
template <typename T1, typename T2>
struct hash<std::pair<T1, T2> > {
- public:
+ public:
size_t operator()(const std::pair<T1, T2>& x) const {
return folly::hash::hash_combine(x.first, x.second);
}
}
};
} // namespace std
-
-#endif