Commit 73c483aa authored by Nathan Bronson's avatar Nathan Bronson Committed by Facebook Github Bot

clang-format in preparation for other changes

Summary:
This diff clang-formats a couple of files in preparation for
additional changes.

Reviewed By: yfeldblum, shixiao

Differential Revision: D7197983

fbshipit-source-id: 8995bdaca29bcc44cd5379fc64c76cee89635ac1
parent 92dbb6a8
......@@ -33,7 +33,8 @@
* Various hashing functions.
*/
namespace folly { namespace hash {
namespace folly {
namespace hash {
// This is a general-purpose way to create a single hash from multiple
// hashable objects. hash_combine_generic takes a class Hasher implementing
......@@ -41,7 +42,6 @@ namespace folly { namespace hash {
// hash_combine_generic hashes each argument and combines those hashes in
// an order-dependent way to yield a new hash.
// This is the Hash128to64 function from Google's cityhash (available
// under the MIT License). We use it to reduce multiple 64 bit hashes
// into a single hash.
......@@ -65,10 +65,8 @@ inline size_t hash_combine_generic() {
template <
class Iter,
class Hash = std::hash<typename std::iterator_traits<Iter>::value_type>>
uint64_t hash_range(Iter begin,
Iter end,
uint64_t hash = 0,
Hash hasher = Hash()) {
uint64_t
hash_range(Iter begin, Iter end, uint64_t hash = 0, Hash hasher = Hash()) {
for (; begin != end; ++begin) {
hash = hash_128_to_64(hash, hasher(*begin));
}
......@@ -115,13 +113,13 @@ size_t hash_combine(const T& t, const Ts&... ts) {
*/
inline uint64_t twang_mix64(uint64_t key) {
key = (~key) + (key << 21); // key *= (1 << 21) - 1; key -= 1;
key = (~key) + (key << 21); // key *= (1 << 21) - 1; key -= 1;
key = key ^ (key >> 24);
key = key + (key << 3) + (key << 8); // key *= 1 + (1 << 3) + (1 << 8)
key = key + (key << 3) + (key << 8); // key *= 1 + (1 << 3) + (1 << 8)
key = key ^ (key >> 14);
key = key + (key << 2) + (key << 4); // key *= 1 + (1 << 2) + (1 << 4)
key = key + (key << 2) + (key << 4); // key *= 1 + (1 << 2) + (1 << 4)
key = key ^ (key >> 28);
key = key + (key << 31); // key *= 1 + (1 << 31)
key = key + (key << 31); // key *= 1 + (1 << 31)
return key;
}
......@@ -155,7 +153,7 @@ inline uint32_t twang_32from64(uint64_t key) {
key = key ^ (key >> 11);
key = key + (key << 6);
key = key ^ (key >> 22);
return (uint32_t) key;
return (uint32_t)key;
}
/*
......@@ -163,11 +161,11 @@ inline uint32_t twang_32from64(uint64_t key) {
*/
inline uint32_t jenkins_rev_mix32(uint32_t key) {
key += (key << 12); // key *= (1 + (1 << 12))
key += (key << 12); // key *= (1 + (1 << 12))
key ^= (key >> 22);
key += (key << 4); // key *= (1 + (1 << 4))
key += (key << 4); // key *= (1 + (1 << 4))
key ^= (key >> 9);
key += (key << 10); // key *= (1 + (1 << 10))
key += (key << 10); // key *= (1 + (1 << 10))
key ^= (key >> 2);
// key *= (1 + (1 << 7)) * (1 + (1 << 12))
key += (key << 7);
......@@ -194,11 +192,9 @@ inline uint32_t jenkins_rev_unmix32(uint32_t key) {
// for (int i = n; i < 32; i += n) {
// b ^= (a >> i);
// }
key ^=
(key >> 2) ^ (key >> 4) ^ (key >> 6) ^ (key >> 8) ^
(key >> 10) ^ (key >> 12) ^ (key >> 14) ^ (key >> 16) ^
(key >> 18) ^ (key >> 20) ^ (key >> 22) ^ (key >> 24) ^
(key >> 26) ^ (key >> 28) ^ (key >> 30);
key ^= (key >> 2) ^ (key >> 4) ^ (key >> 6) ^ (key >> 8) ^ (key >> 10) ^
(key >> 12) ^ (key >> 14) ^ (key >> 16) ^ (key >> 18) ^ (key >> 20) ^
(key >> 22) ^ (key >> 24) ^ (key >> 26) ^ (key >> 28) ^ (key >> 30);
key *= 3222273025U;
key ^= (key >> 9) ^ (key >> 18) ^ (key >> 27);
key *= 4042322161U;
......@@ -221,30 +217,30 @@ inline uint32_t fnv32(const char* buf, uint32_t hash = FNV_32_HASH_START) {
const signed char* s = reinterpret_cast<const signed char*>(buf);
for (; *s; ++s) {
hash += (hash << 1) + (hash << 4) + (hash << 7) +
(hash << 8) + (hash << 24);
hash +=
(hash << 1) + (hash << 4) + (hash << 7) + (hash << 8) + (hash << 24);
hash ^= *s;
}
return hash;
}
inline uint32_t fnv32_buf(const void* buf,
size_t n,
uint32_t hash = FNV_32_HASH_START) {
inline uint32_t
fnv32_buf(const void* buf, size_t n, uint32_t hash = FNV_32_HASH_START) {
// forcing signed char, since other platforms can use unsigned
const signed char* char_buf = reinterpret_cast<const signed char*>(buf);
for (size_t i = 0; i < n; ++i) {
hash += (hash << 1) + (hash << 4) + (hash << 7) +
(hash << 8) + (hash << 24);
hash +=
(hash << 1) + (hash << 4) + (hash << 7) + (hash << 8) + (hash << 24);
hash ^= char_buf[i];
}
return hash;
}
inline uint32_t fnv32(const std::string& str,
uint32_t hash = FNV_32_HASH_START) {
inline uint32_t fnv32(
const std::string& str,
uint32_t hash = FNV_32_HASH_START) {
return fnv32_buf(str.data(), str.size(), hash);
}
......@@ -254,46 +250,46 @@ inline uint64_t fnv64(const char* buf, uint64_t hash = FNV_64_HASH_START) {
for (; *s; ++s) {
hash += (hash << 1) + (hash << 4) + (hash << 5) + (hash << 7) +
(hash << 8) + (hash << 40);
(hash << 8) + (hash << 40);
hash ^= *s;
}
return hash;
}
inline uint64_t fnv64_buf(const void* buf,
size_t n,
uint64_t hash = FNV_64_HASH_START) {
inline uint64_t
fnv64_buf(const void* buf, size_t n, uint64_t hash = FNV_64_HASH_START) {
// forcing signed char, since other platforms can use unsigned
const signed char* char_buf = reinterpret_cast<const signed char*>(buf);
for (size_t i = 0; i < n; ++i) {
hash += (hash << 1) + (hash << 4) + (hash << 5) + (hash << 7) +
(hash << 8) + (hash << 40);
(hash << 8) + (hash << 40);
hash ^= char_buf[i];
}
return hash;
}
inline uint64_t fnv64(const std::string& str,
uint64_t hash = FNV_64_HASH_START) {
inline uint64_t fnv64(
const std::string& str,
uint64_t hash = FNV_64_HASH_START) {
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) {
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);
(hash << 8) + (hash << 40);
}
return hash;
}
inline uint64_t fnva64(const std::string& str,
uint64_t hash = FNVA_64_HASH_START) {
inline uint64_t fnva64(
const std::string& str,
uint64_t hash = FNVA_64_HASH_START) {
return fnva64_buf(str.data(), str.size(), hash);
}
......@@ -318,31 +314,31 @@ inline uint32_t hsieh_hash32_buf(const void* buf, size_t len) {
len >>= 2;
/* Main loop */
for (;len > 0; len--) {
hash += get16bits (s);
tmp = (get16bits (s+2) << 11) ^ hash;
hash = (hash << 16) ^ tmp;
s += 2*sizeof (uint16_t);
hash += hash >> 11;
for (; len > 0; len--) {
hash += get16bits(s);
tmp = (get16bits(s + 2) << 11) ^ hash;
hash = (hash << 16) ^ tmp;
s += 2 * sizeof(uint16_t);
hash += hash >> 11;
}
/* Handle end cases */
switch (rem) {
case 3:
hash += get16bits(s);
hash ^= hash << 16;
hash ^= s[sizeof (uint16_t)] << 18;
hash += hash >> 11;
break;
case 2:
hash += get16bits(s);
hash ^= hash << 11;
hash += hash >> 17;
break;
case 1:
hash += *s;
hash ^= hash << 10;
hash += hash >> 1;
case 3:
hash += get16bits(s);
hash ^= hash << 16;
hash ^= s[sizeof(uint16_t)] << 18;
hash += hash >> 11;
break;
case 2:
hash += get16bits(s);
hash ^= hash << 11;
hash += hash >> 17;
break;
case 1:
hash += *s;
hash ^= hash << 10;
hash += hash >> 1;
}
/* Force "avalanching" of final 127 bits */
......@@ -487,7 +483,8 @@ struct hasher<float> : detail::float_hasher<float> {};
template <>
struct hasher<double> : detail::float_hasher<double> {};
template <> struct hasher<std::string> {
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));
......@@ -510,7 +507,7 @@ struct hasher<std::pair<T1, T2>> {
template <typename... Ts>
struct hasher<std::tuple<Ts...>> {
size_t operator() (const std::tuple<Ts...>& key) const {
size_t operator()(const std::tuple<Ts...>& key) const {
return applyTuple(Hash(), key);
}
};
......@@ -520,8 +517,7 @@ template <size_t index, typename... Ts>
struct TupleHasher {
size_t operator()(std::tuple<Ts...> const& key) const {
return hash::hash_combine(
TupleHasher<index - 1, Ts...>()(key),
std::get<index>(key));
TupleHasher<index - 1, Ts...>()(key), std::get<index>(key));
}
};
......@@ -551,7 +547,7 @@ struct hash<unsigned __int128>
// Hash function for pairs. Requires default hash functions for both
// items in the pair.
template <typename T1, typename T2>
struct hash<std::pair<T1, T2> > {
struct hash<std::pair<T1, T2>> {
public:
size_t operator()(const std::pair<T1, T2>& x) const {
return folly::hash::hash_combine(x.first, x.second);
......@@ -563,8 +559,9 @@ template <typename... Ts>
struct hash<std::tuple<Ts...>> {
size_t operator()(std::tuple<Ts...> const& key) const {
folly::TupleHasher<
std::tuple_size<std::tuple<Ts...>>::value - 1, // start index
Ts...> hasher;
std::tuple_size<std::tuple<Ts...>>::value - 1, // start index
Ts...>
hasher;
return hasher(key);
}
......
......@@ -15,13 +15,16 @@
*/
#include <folly/hash/Hash.h>
#include <folly/MapUtil.h>
#include <folly/portability/GTest.h>
#include <stdint.h>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <folly/MapUtil.h>
#include <folly/portability/GTest.h>
using namespace folly::hash;
TEST(Hash, Fnv32) {
......@@ -76,17 +79,12 @@ TEST(Hash, Fnv64) {
int32_t t4_c = 0xAB12CD34;
const char* t4_d = "Unum";
uint64_t t4_res = 15571330457339273965ULL;
uint64_t t4_hash1 = fnv64_buf(t4_a,
strlen(t4_a));
uint64_t t4_hash2 = fnv64_buf(reinterpret_cast<void*>(&t4_b),
sizeof(int64_t),
t4_hash1);
uint64_t t4_hash3 = fnv64_buf(reinterpret_cast<void*>(&t4_c),
sizeof(int32_t),
t4_hash2);
uint64_t t4_hash4 = fnv64_buf(t4_d,
strlen(t4_d),
t4_hash3);
uint64_t t4_hash1 = fnv64_buf(t4_a, strlen(t4_a));
uint64_t t4_hash2 =
fnv64_buf(reinterpret_cast<void*>(&t4_b), sizeof(int64_t), t4_hash1);
uint64_t t4_hash3 =
fnv64_buf(reinterpret_cast<void*>(&t4_c), sizeof(int32_t), t4_hash2);
uint64_t t4_hash4 = fnv64_buf(t4_d, strlen(t4_d), t4_hash3);
EXPECT_EQ(t4_hash4, t4_res);
// note: These are probabalistic, not determinate, but c'mon.
// These hash values should be different, or something's not
......@@ -181,7 +179,7 @@ TEST(Hash, Jenkins_Rev_Unmix32) {
TEST(Hash, hasher) {
// Basically just confirms that things compile ok.
std::unordered_map<int32_t,int32_t,folly::hasher<int32_t>> m;
std::unordered_map<int32_t, int32_t, folly::hasher<int32_t>> m;
m.insert(std::make_pair(4, 5));
EXPECT_EQ(get_default(m, 4), 5);
}
......@@ -280,38 +278,27 @@ TEST(Hash, pair) {
auto b = std::make_pair(3, 4);
auto c = std::make_pair(1, 2);
auto d = std::make_pair(2, 1);
EXPECT_EQ(hash_combine(a),
hash_combine(c));
EXPECT_NE(hash_combine(b),
hash_combine(c));
EXPECT_NE(hash_combine(d),
hash_combine(c));
EXPECT_EQ(hash_combine(a), hash_combine(c));
EXPECT_NE(hash_combine(b), hash_combine(c));
EXPECT_NE(hash_combine(d), hash_combine(c));
// With composition
EXPECT_EQ(hash_combine(a, b),
hash_combine(c, b));
EXPECT_EQ(hash_combine(a, b), hash_combine(c, b));
// Test order dependence
EXPECT_NE(hash_combine(a, b),
hash_combine(b, a));
EXPECT_NE(hash_combine(a, b), hash_combine(b, a));
// Test with custom hasher
EXPECT_EQ(hash_combine_test(a),
hash_combine_test(c));
EXPECT_EQ(hash_combine_test(a), hash_combine_test(c));
// 3 + 4 != 1 + 2
EXPECT_NE(hash_combine_test(b),
hash_combine_test(c));
EXPECT_NE(hash_combine_test(b), hash_combine_test(c));
// This time, thanks to a terrible hash function, these are equal
EXPECT_EQ(hash_combine_test(d),
hash_combine_test(c));
EXPECT_EQ(hash_combine_test(d), hash_combine_test(c));
// With composition
EXPECT_EQ(hash_combine_test(a, b),
hash_combine_test(c, b));
EXPECT_EQ(hash_combine_test(a, b), hash_combine_test(c, b));
// Test order dependence
EXPECT_NE(hash_combine_test(a, b),
hash_combine_test(b, a));
EXPECT_NE(hash_combine_test(a, b), hash_combine_test(b, a));
// Again, 1 + 2 == 2 + 1
EXPECT_EQ(hash_combine_test(a, b),
hash_combine_test(d, b));
EXPECT_EQ(hash_combine_test(a, b), hash_combine_test(d, b));
}
TEST(Hash, hash_combine) {
......@@ -419,18 +406,15 @@ TEST(Hash, std_tuple_different_hash) {
tuple3 t2(9, "bar", 3);
tuple3 t3(42, "foo", 3);
EXPECT_NE(std::hash<tuple3>()(t1),
std::hash<tuple3>()(t2));
EXPECT_NE(std::hash<tuple3>()(t1),
std::hash<tuple3>()(t3));
EXPECT_NE(std::hash<tuple3>()(t1), std::hash<tuple3>()(t2));
EXPECT_NE(std::hash<tuple3>()(t1), std::hash<tuple3>()(t3));
}
TEST(Hash, Strings) {
using namespace folly;
StringPiece a1 = "10050517", b1 = "51107032",
a2 = "10050518", b2 = "51107033",
a3 = "10050519", b3 = "51107034",
StringPiece a1 = "10050517", b1 = "51107032", a2 = "10050518",
b2 = "51107033", a3 = "10050519", b3 = "51107034",
a4 = "10050525", b4 = "51107040";
Range<const wchar_t*> w1 = range(L"10050517"), w2 = range(L"51107032"),
w3 = range(L"10050518"), w4 = range(L"51107033");
......@@ -462,8 +446,8 @@ struct FNVTestParam {
class FNVTest : public ::testing::TestWithParam<FNVTestParam> {};
TEST_P(FNVTest, Fnva64Buf) {
EXPECT_EQ(GetParam().out,
fnva64_buf(GetParam().in.data(), GetParam().in.size()));
EXPECT_EQ(
GetParam().out, fnva64_buf(GetParam().in.data(), GetParam().in.size()));
}
TEST_P(FNVTest, Fnva64) {
......@@ -474,9 +458,10 @@ TEST_P(FNVTest, Fnva64Partial) {
size_t partialLen = GetParam().in.size() / 2;
auto data = GetParam().in.data();
auto partial = fnva64_buf(data, partialLen);
EXPECT_EQ(GetParam().out,
fnva64_buf(
data + partialLen, GetParam().in.size() - partialLen, partial));
EXPECT_EQ(
GetParam().out,
fnva64_buf(
data + partialLen, GetParam().in.size() - partialLen, partial));
}
// Taken from http://www.isthe.com/chongo/src/fnv/test_fnv.c
......
Markdown is supported
0%
or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment