hash_internal

Records

class is_uniquely_represented<unsigned char, void>

class is_uniquely_represented<Integral, std::enable_if_t<std::is_integral_v<Integral>>>

class is_uniquely_represented<bool, void>

class is_uniquely_represented<__int128, void>

class is_uniquely_represented<unsigned __int128, void>

Functions

```
template <typename H>
```
```
H AbslHashValue (H hash_state, std::nullptr_t )
```
AbslHashValue() for hashing nullptr_t

Defined at line 552 of file ../../third_party/abseil-cpp/src/absl/hash/internal/hash.h
```
template <typename H, typename T, typename C>
```
```
H AbslHashValue (H hash_state, T C::* ptr)
```
AbslHashValue() for hashing pointers-to-member

Defined at line 558 of file ../../third_party/abseil-cpp/src/absl/hash/internal/hash.h

template <typename H, typename T1, typename T2>

std::enable_if_t<is_hashable<T1>::value && is_hashable<T2>::value, H> AbslHashValue (H hash_state, const std::pair<T1, T2> & p)

AbslHashValue() for hashing pairs

Defined at line 595 of file ../../third_party/abseil-cpp/src/absl/hash/internal/hash.h

```
template <typename H, typename T, typename Allocator>
```
```
std::enable_if_t<is_hashable<T>::value && ! std::is_same_v<T, bool>, H> AbslHashValue (H hash_state, const std::vector<T, Allocator> & vector)
```
AbslHashValue for hashing std::vector

Do not use this for vector

<bool

> on platforms that have a working

implementation of std::hash. It does not have a .data(), and a fallback for

std::hash

<

> is most likely faster.

Defined at line 783 of file ../../third_party/abseil-cpp/src/absl/hash/internal/hash.h
```
template <typename H, typename T, typename Allocator>
```
```
std::enable_if_t<is_hashable<T>::value && std::is_same_v<T, bool>, H> AbslHashValue (H hash_state, const std::vector<T, Allocator> & vector)
```
When not working around the libstdc++ bug above, we still have to contend

with the fact that std::hash

<vector

<bool

>> is often poor quality, hashing

directly on the internal words and on no other state. On these platforms,

vector

<bool

>{1, 1} and vector

<bool

>{1, 1, 0} hash to the same value.

Mixing in the size (as we do in our other vector

<

> implementations) on top

of the library-provided hash implementation avoids this QOI issue.

Defined at line 818 of file ../../third_party/abseil-cpp/src/absl/hash/internal/hash.h

template <typename H, typename Key, typename T, typename Compare, typename Allocator>

std::enable_if_t<is_hashable<Key>::value && is_hashable<T>::value, H> AbslHashValue (H hash_state, const std::map<Key, T, Compare, Allocator> & map)

AbslHashValue for hashing std::map

Defined at line 833 of file ../../third_party/abseil-cpp/src/absl/hash/internal/hash.h

template <typename H, typename Key, typename T, typename Compare, typename Allocator>

std::enable_if_t<is_hashable<Key>::value && is_hashable<T>::value, H> AbslHashValue (H hash_state, const std::multimap<Key, T, Compare, Allocator> & map)

AbslHashValue for hashing std::multimap

Defined at line 844 of file ../../third_party/abseil-cpp/src/absl/hash/internal/hash.h

template <typename H, typename Key, typename Compare, typename Allocator>

std::enable_if_t<is_hashable<Key>::value, H> AbslHashValue (H hash_state, const std::set<Key, Compare, Allocator> & set)

AbslHashValue for hashing std::set

Defined at line 855 of file ../../third_party/abseil-cpp/src/absl/hash/internal/hash.h

template <typename H, typename Key, typename Compare, typename Allocator>

std::enable_if_t<is_hashable<Key>::value, H> AbslHashValue (H hash_state, const std::multiset<Key, Compare, Allocator> & set)

AbslHashValue for hashing std::multiset

Defined at line 865 of file ../../third_party/abseil-cpp/src/absl/hash/internal/hash.h

template <typename H, typename Key, typename Hash, typename KeyEqual, typename Alloc>

std::enable_if_t<is_hashable<Key>::value, H> AbslHashValue (H hash_state, const std::unordered_set<Key, Hash, KeyEqual, Alloc> & s)

AbslHashValue for hashing std::unordered_set

Defined at line 880 of file ../../third_party/abseil-cpp/src/absl/hash/internal/hash.h

template <typename H, typename Key, typename Hash, typename KeyEqual, typename Alloc>

std::enable_if_t<is_hashable<Key>::value, H> AbslHashValue (H hash_state, const std::unordered_multiset<Key, Hash, KeyEqual, Alloc> & s)

AbslHashValue for hashing std::unordered_multiset

Defined at line 890 of file ../../third_party/abseil-cpp/src/absl/hash/internal/hash.h

template <typename H, typename Key, typename T, typename Hash, typename KeyEqual, typename Alloc>

std::enable_if_t<is_hashable<Key>::value && is_hashable<T>::value, H> AbslHashValue (H hash_state, const std::unordered_map<Key, T, Hash, KeyEqual, Alloc> & s)

AbslHashValue for hashing std::unordered_set

Defined at line 901 of file ../../third_party/abseil-cpp/src/absl/hash/internal/hash.h

template <typename H, typename Key, typename T, typename Hash, typename KeyEqual, typename Alloc>

std::enable_if_t<is_hashable<Key>::value && is_hashable<T>::value, H> AbslHashValue (H hash_state, const std::unordered_multimap<Key, T, Hash, KeyEqual, Alloc> & s)

AbslHashValue for hashing std::unordered_multiset

Defined at line 912 of file ../../third_party/abseil-cpp/src/absl/hash/internal/hash.h

template <typename H, typename T>

std::enable_if_t<is_hashable<T>::value, H> AbslHashValue (H hash_state, std::reference_wrapper<T> opt)

AbslHashValue for hashing std::reference_wrapper

Defined at line 926 of file ../../third_party/abseil-cpp/src/absl/hash/internal/hash.h

template <typename H, typename T>

std::enable_if_t<is_hashable<T>::value, H> AbslHashValue (H hash_state, const std::optional<T> & opt)

AbslHashValue for hashing std::optional

Defined at line 933 of file ../../third_party/abseil-cpp/src/absl/hash/internal/hash.h

template <typename H, typename... T>

std::enable_if_t<std::conjunction_v<is_hashable<T>...>, H> AbslHashValue (H hash_state, const std::variant<T...> & v)

AbslHashValue for hashing std::variant

Defined at line 950 of file ../../third_party/abseil-cpp/src/absl/hash/internal/hash.h

uint64_t CityHash64 (const char * s, size_t len)

Hash function for a byte array.

```
uint64_t CityHash64WithSeed (const char * s, size_t len, uint64_t seed)
```
Hash function for a byte array. For convenience, a 64-bit seed is also

hashed into the result.

uint64_t CityHash64WithSeeds (const char * s, size_t len, uint64_t seed0, uint64_t seed1)

Hash function for a byte array. For convenience, two seeds are also

hashed into the result.

```
uint32_t CityHash32 (const char * s, size_t len)
```
Hash function for a byte array. Most useful in 32-bit binaries.
```
size_t PiecewiseChunkSize ()
```
Internal detail: Large buffers are hashed in smaller chunks. This function

returns the size of these chunks.

Defined at line 157 of file ../../third_party/abseil-cpp/src/absl/hash/internal/hash.h
```
template <typename H, typename T, std::enable_if_t<FitsIn64Bits<T>::value, int> = 0>
```
```
H hash_bytes (H hash_state, const T & value)
```
Convenience function that combines `hash_state` with the byte representation

of `value`.

Defined at line 422 of file ../../third_party/abseil-cpp/src/absl/hash/internal/hash.h

template <typename H, typename T, std::enable_if_t<!FitsIn64Bits<T>::value, int> = 0>

H hash_bytes (H hash_state, const T & value)

Defined at line 439 of file ../../third_party/abseil-cpp/src/absl/hash/internal/hash.h

template <typename H>

H hash_weakly_mixed_integer (H hash_state, WeaklyMixedInteger value)

Defined at line 445 of file ../../third_party/abseil-cpp/src/absl/hash/internal/hash.h

```
template <typename H, typename B>
```
```
std::enable_if_t<std::is_same_v<B, bool>, H> AbslHashValue (H hash_state, B value)
```
AbslHashValue() for hashing bool values

We use SFINAE to ensure that this overload only accepts bool, not types that

are convertible to bool.

Defined at line 463 of file ../../third_party/abseil-cpp/src/absl/hash/internal/hash.h
```
template <typename H, typename Enum>
```
```
std::enable_if_t<std::is_enum_v<Enum>, H> AbslHashValue (H hash_state, Enum e)
```
AbslHashValue() for hashing enum values

Defined at line 473 of file ../../third_party/abseil-cpp/src/absl/hash/internal/hash.h

template <typename H, typename Float>

std::enable_if_t<std::is_same_v<Float, float> || std::is_same_v<Float, double>, H> AbslHashValue (H hash_state, Float value)

AbslHashValue() for hashing floating-point values

Defined at line 484 of file ../../third_party/abseil-cpp/src/absl/hash/internal/hash.h

```
template <typename H, typename LongDouble>
```
```
std::enable_if_t<std::is_same_v<LongDouble, long double>, H> AbslHashValue (H hash_state, LongDouble value)
```
Long double has the property that it might have extra unused bytes in it.

For example, in x86 sizeof(long double)==16 but it only really uses 80-bits

of it. This means we can't use hash_bytes on a long double and have to

convert it to something else first.

Defined at line 496 of file ../../third_party/abseil-cpp/src/absl/hash/internal/hash.h
```
template <typename H, typename T, size_t N>
```
```
H AbslHashValue (H hash_state, T (&)[N] )
```
Without this overload, an array decays to a pointer and we hash that, which

is not likely to be what the caller intended.

Defined at line 529 of file ../../third_party/abseil-cpp/src/absl/hash/internal/hash.h
```
template <typename H, typename T>
```
```
std::enable_if_t<std::is_pointer_v<T>, H> AbslHashValue (H hash_state, T ptr)
```
AbslHashValue() for hashing pointers

Defined at line 541 of file ../../third_party/abseil-cpp/src/absl/hash/internal/hash.h
```
template <typename H, typename Tuple, size_t... Is>
```
```
H hash_tuple (H hash_state, const Tuple & t, std::index_sequence<Is...> )
```
Helper function for hashing a tuple. The third argument should

be an index_sequence running from 0 to tuple_size

<Tuple

> - 1.

Defined at line 603 of file ../../third_party/abseil-cpp/src/absl/hash/internal/hash.h

template <typename H, typename... Ts>

std::enable_if_t<std::conjunction_v<is_hashable<Ts>...>, H> AbslHashValue (H hash_state, const std::tuple<Ts...> & t)

Defined at line 614 of file ../../third_party/abseil-cpp/src/absl/hash/internal/hash.h

```
template <typename H, typename T, typename D>
```
```
H AbslHashValue (H hash_state, const std::unique_ptr<T, D> & ptr)
```
AbslHashValue for hashing unique_ptr

Defined at line 627 of file ../../third_party/abseil-cpp/src/absl/hash/internal/hash.h
```
template <typename H, typename T>
```
```
H AbslHashValue (H hash_state, const std::shared_ptr<T> & ptr)
```
AbslHashValue for hashing shared_ptr

Defined at line 633 of file ../../third_party/abseil-cpp/src/absl/hash/internal/hash.h
```
template <typename H>
```
```
H AbslHashValue (H hash_state, absl::string_view str)
```
AbslHashValue for hashing strings

All the string-like types supported here provide the same hash expansion for

the same character sequence. These types are:

- `absl::Cord`

- `std::string` (and std::basic_string

<T

, std::char_traits

<T

>, A> for

any allocator A and any T in {char, wchar_t, char8_t, char16_t,

char32_t})

- `absl::string_view`, `std::string_view`, `std::wstring_view`,

`std::u8string_view`, `std::u16string_view`, and `std::u32_string_view`.

For simplicity, we currently support only strings built on `char`, `wchar_t`,

`char8_t`, `char16_t`, or `char32_t`. This support may be broadened, if

necessary, but with some caution - this overload would misbehave in cases

where the traits' `eq()` member isn't equivalent to `==` on the underlying

character type.

Defined at line 659 of file ../../third_party/abseil-cpp/src/absl/hash/internal/hash.h

template <typename Char, typename Alloc, typename H, typename = std::enable_if_t<std::is_same_v<Char, wchar_t> ||
                            #ifdef __cpp_char8_t
                                                                  std::is_same_v<Char, char8_t> ||
                            #endif
                                                                  std::is_same_v<Char, char16_t> ||
                                                                  std::is_same_v<Char, char32_t>>>

H AbslHashValue (H hash_state, const std::basic_string<Char, std::char_traits<Char>, Alloc> & str)

Defined at line 671 of file ../../third_party/abseil-cpp/src/absl/hash/internal/hash.h

template <typename Char, typename H, typename = std::enable_if_t<std::is_same_v<Char, wchar_t> ||
                            #ifdef __cpp_char8_t
                                                                  std::is_same_v<Char, char8_t> ||
                            #endif
                                                                  std::is_same_v<Char, char16_t> ||
                                                                  std::is_same_v<Char, char32_t>>>

H AbslHashValue (H hash_state, std::basic_string_view<Char> str)

Defined at line 686 of file ../../third_party/abseil-cpp/src/absl/hash/internal/hash.h

```
template <typename Path, typename H, typename = std::enable_if_t<
                                          std::is_same_v<Path, std::filesystem::path>>>
```
```
H AbslHashValue (H hash_state, const Path & path)
```
Support std::filesystem::path. The SFINAE is required because some string

types are implicitly convertible to std::filesystem::path.

Defined at line 704 of file ../../third_party/abseil-cpp/src/absl/hash/internal/hash.h

template <typename H, typename T, size_t N>

std::enable_if_t<is_hashable<T>::value, H> AbslHashValue (H hash_state, const std::array<T, N> & array)

AbslHashValue for hashing std::array

Defined at line 737 of file ../../third_party/abseil-cpp/src/absl/hash/internal/hash.h

template <typename H, typename T, typename Allocator>

std::enable_if_t<is_hashable<T>::value, H> AbslHashValue (H hash_state, const std::deque<T, Allocator> & deque)

AbslHashValue for hashing std::deque

Defined at line 745 of file ../../third_party/abseil-cpp/src/absl/hash/internal/hash.h

template <typename H, typename T, typename Allocator>

std::enable_if_t<is_hashable<T>::value, H> AbslHashValue (H hash_state, const std::forward_list<T, Allocator> & list)

AbslHashValue for hashing std::forward_list

Defined at line 757 of file ../../third_party/abseil-cpp/src/absl/hash/internal/hash.h

template <typename H, typename T, typename Allocator>

std::enable_if_t<is_hashable<T>::value, H> AbslHashValue (H hash_state, const std::list<T, Allocator> & list)

AbslHashValue for hashing std::list

Defined at line 769 of file ../../third_party/abseil-cpp/src/absl/hash/internal/hash.h

```
template <typename H, typename T>
```
```
std::enable_if_t<is_uniquely_represented<T>::value, H> hash_range_or_bytes (H hash_state, const T * data, size_t size)
```
Mixes all values in the range [data, data+size) into the hash state.

This overload accepts only uniquely-represented types, and hashes them by

hashing the entire range of bytes.

Defined at line 991 of file ../../third_party/abseil-cpp/src/absl/hash/internal/hash.h

template <typename H, typename T>

std::enable_if_t<! is_uniquely_represented<T>::value, H> hash_range_or_bytes (H hash_state, const T * data, size_t size)

Defined at line 998 of file ../../third_party/abseil-cpp/src/absl/hash/internal/hash.h

```
uint64_t PrecombineLengthMix (uint64_t state, size_t len)
```
Extremely weak mixture of length that is mixed into the state before

combining the data. It is used only for small strings. This also ensures that

we have high entropy in all bits of the state.

Defined at line 1019 of file ../../third_party/abseil-cpp/src/absl/hash/internal/hash.h
```
uint64_t Mix (uint64_t lhs, uint64_t rhs)
```
Defined at line 1026 of file ../../third_party/abseil-cpp/src/absl/hash/internal/hash.h
```
uint32_t Read4 (const unsigned char * p)
```
Defined at line 1039 of file ../../third_party/abseil-cpp/src/absl/hash/internal/hash.h
```
uint64_t Read8 (const unsigned char * p)
```
Defined at line 1042 of file ../../third_party/abseil-cpp/src/absl/hash/internal/hash.h
```
std::pair<uint64_t, uint64_t> Read9To16 (const unsigned char * p, size_t len)
```
Reads 9 to 16 bytes from p.

The first 8 bytes are in .first, and the rest of the bytes are in .second

along with duplicated bytes from .first if len

<

16.

Defined at line 1052 of file ../../third_party/abseil-cpp/src/absl/hash/internal/hash.h
```
uint64_t Read4To8 (const unsigned char * p, size_t len)
```
Reads 4 to 8 bytes from p.

Bytes are permuted and some input bytes may be duplicated in output.

Defined at line 1059 of file ../../third_party/abseil-cpp/src/absl/hash/internal/hash.h
```
uint32_t Read1To3 (const unsigned char * p, size_t len)
```
Reads 1 to 3 bytes from p. Some input bytes may be duplicated in output.

Defined at line 1079 of file ../../third_party/abseil-cpp/src/absl/hash/internal/hash.h

uint64_t CombineContiguousImpl9to16 (uint64_t state, const unsigned char * first, size_t len)

Defined at line 1164 of file ../../third_party/abseil-cpp/src/absl/hash/internal/hash.h

uint64_t CombineContiguousImpl17to32 (uint64_t state, const unsigned char * first, size_t len)

Defined at line 1177 of file ../../third_party/abseil-cpp/src/absl/hash/internal/hash.h

```
uint64_t CombineContiguousImpl (uint64_t state, const unsigned char * first, size_t len, std::integral_constant<int, 4> )
```
Implementation of the base case for combine_contiguous where we actually

mix the bytes into the state.

Dispatch to different implementations of combine_contiguous depending

on the value of `sizeof(size_t)`.

Defined at line 1196 of file ../../third_party/abseil-cpp/src/absl/hash/internal/hash.h

uint64_t CombineContiguousImpl (uint64_t state, const unsigned char * first, size_t len, std::integral_constant<int, 8> )

Defined at line 1272 of file ../../third_party/abseil-cpp/src/absl/hash/internal/hash.h

```
uint64_t CombineLargeContiguousImplOn32BitLengthGt8 (uint64_t state, const unsigned char * first, size_t len)
```
Slow dispatch path for calls to CombineContiguousImpl with a size argument

larger than inlined size. Has the same effect as calling

CombineContiguousImpl() repeatedly with the chunk stride size.

uint64_t CombineLargeContiguousImplOn64BitLengthGt32 (uint64_t state, const unsigned char * first, size_t len)

```
uint64_t CombineRawImpl (uint64_t state, uint64_t value)
```
Defined at line 1133 of file ../../third_party/abseil-cpp/src/absl/hash/internal/hash.h

uint64_t CombineSmallContiguousImpl (uint64_t state, const unsigned char * first, size_t len)

Defined at line 1149 of file ../../third_party/abseil-cpp/src/absl/hash/internal/hash.h

Variables

const uint64_t kMul

Defined at line 1007 of file ../../third_party/abseil-cpp/src/absl/hash/internal/hash.h

const uint64_t[5] kStaticRandomData

Defined at line 1011 of file ../../third_party/abseil-cpp/src/absl/hash/internal/hash.h