hash_internal

Records

class is_uniquely_represented<unsigned char, void>

class is_uniquely_represented<Integral, typename std::enable_if<std::is_integral<Integral>::value>::type>

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 539 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 545 of file ../../third_party/abseil-cpp/src/absl/hash/internal/hash.h

template <typename H, typename T1, typename T2>

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

AbslHashValue() for hashing pairs

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

```
template <typename H, typename T, typename Allocator>
```
```
typename std::enable_if<is_hashable<T>::value && ! std::is_same<T, bool>::value, H>::type 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 746 of file ../../third_party/abseil-cpp/src/absl/hash/internal/hash.h
```
template <typename H, typename T, typename Allocator>
```
```
typename std::enable_if<is_hashable<T>::value && std::is_same<T, bool>::value, H>::type 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 783 of file ../../third_party/abseil-cpp/src/absl/hash/internal/hash.h

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

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

AbslHashValue for hashing std::map

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

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

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

AbslHashValue for hashing std::multimap

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

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

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

AbslHashValue for hashing std::set

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

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

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

AbslHashValue for hashing std::multiset

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

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

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

AbslHashValue for hashing std::unordered_set

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

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

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

AbslHashValue for hashing std::unordered_multiset

Defined at line 858 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>

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

AbslHashValue for hashing std::unordered_set

Defined at line 869 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>

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

AbslHashValue for hashing std::unordered_multiset

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

template <typename H, typename T>

typename std::enable_if<is_hashable<T>::value, H>::type AbslHashValue (H hash_state, std::reference_wrapper<T> opt)

AbslHashValue for hashing std::reference_wrapper

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

template <typename H, typename T>

typename std::enable_if<is_hashable<T>::value, H>::type AbslHashValue (H hash_state, const absl::optional<T> & opt)

AbslHashValue for hashing absl::optional

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

template <typename H, typename... T>

typename std::enable_if<conjunction<is_hashable<T>...>::value, H>::type AbslHashValue (H hash_state, const absl::variant<T...> & v)

AbslHashValue for hashing absl::variant

Defined at line 920 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 141 of file ../../third_party/abseil-cpp/src/absl/hash/internal/hash.h
```
template <typename H, typename T, absl::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 406 of file ../../third_party/abseil-cpp/src/absl/hash/internal/hash.h

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

H hash_bytes (H hash_state, const T & value)

Defined at line 423 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 429 of file ../../third_party/abseil-cpp/src/absl/hash/internal/hash.h

```
template <typename H, typename B>
```
```
typename std::enable_if<std::is_same<B, bool>::value, H>::type 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 447 of file ../../third_party/abseil-cpp/src/absl/hash/internal/hash.h

template <typename H, typename Enum>

typename std::enable_if<std::is_enum<Enum>::value, H>::type AbslHashValue (H hash_state, Enum e)

AbslHashValue() for hashing enum values

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

template <typename H, typename Float>

typename std::enable_if<std::is_same<Float, float>::value || std::is_same<Float, double>::value, H>::type AbslHashValue (H hash_state, Float value)

AbslHashValue() for hashing floating-point values

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

```
template <typename H, typename LongDouble>
```
```
typename std::enable_if<std::is_same<LongDouble, long double>::value, H>::type 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 482 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 515 of file ../../third_party/abseil-cpp/src/absl/hash/internal/hash.h
```
template <typename H, typename T>
```
```
std::enable_if_t<std::is_pointer<T>::value, H> AbslHashValue (H hash_state, T ptr)
```
AbslHashValue() for hashing pointers

Defined at line 527 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, absl::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 591 of file ../../third_party/abseil-cpp/src/absl/hash/internal/hash.h

template <typename H, typename... Ts>

typename std::enable_if<absl::conjunction<is_hashable<Ts>...>::value, H>::type AbslHashValue (H hash_state, const std::tuple<Ts...> & t)

Defined at line 602 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 615 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 621 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, char16_t, char32_t})

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

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

For simplicity, we currently support only strings built on `char`, `wchar_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 645 of file ../../third_party/abseil-cpp/src/absl/hash/internal/hash.h

template <typename Char, typename Alloc, typename H, typename = absl::enable_if_t<std::is_same<Char, wchar_t>::value ||
                                                                   std::is_same<Char, char16_t>::value ||
                                                                   std::is_same<Char, char32_t>::value>>

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

Support std::wstring, std::u16string and std::u32string.

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

template <typename Char, typename H, typename = absl::enable_if_t<std::is_same<Char, wchar_t>::value ||
                                                                   std::is_same<Char, char16_t>::value ||
                                                                   std::is_same<Char, char32_t>::value>>

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

Support std::wstring_view, std::u16string_view and std::u32string_view.

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

```
template <typename Path, typename H, typename = absl::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 683 of file ../../third_party/abseil-cpp/src/absl/hash/internal/hash.h

template <typename H, typename T, size_t N>

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

AbslHashValue for hashing std::array

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

template <typename H, typename T, typename Allocator>

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

AbslHashValue for hashing std::deque

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

template <typename H, typename T, typename Allocator>

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

AbslHashValue for hashing std::forward_list

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

template <typename H, typename T, typename Allocator>

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

AbslHashValue for hashing std::list

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

```
template <typename H, typename T>
```
```
typename std::enable_if<is_uniquely_represented<T>::value, H>::type 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 961 of file ../../third_party/abseil-cpp/src/absl/hash/internal/hash.h

template <typename H, typename T>

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

Defined at line 968 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 989 of file ../../third_party/abseil-cpp/src/absl/hash/internal/hash.h
```
uint64_t Mix (uint64_t lhs, uint64_t rhs)
```
Defined at line 996 of file ../../third_party/abseil-cpp/src/absl/hash/internal/hash.h
```
uint32_t Read4 (const unsigned char * p)
```
Defined at line 1009 of file ../../third_party/abseil-cpp/src/absl/hash/internal/hash.h
```
uint64_t Read8 (const unsigned char * p)
```
Defined at line 1012 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 1022 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 1029 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 1049 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 1093 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 1106 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 1125 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 1138 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 1063 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 1078 of file ../../third_party/abseil-cpp/src/absl/hash/internal/hash.h

Variables

const uint64_t kMul

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

const uint64_t[5] kStaticRandomData

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