hash_internal

Records

Functions

```
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 359 of file ../../third_party/abseil-cpp/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 367 of file ../../third_party/abseil-cpp/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 379 of file ../../third_party/abseil-cpp/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 392 of file ../../third_party/abseil-cpp/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 425 of file ../../third_party/abseil-cpp/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 437 of file ../../third_party/abseil-cpp/absl/hash/internal/hash.h
```
template <typename H>
```
```
H AbslHashValue (H hash_state, std::nullptr_t )
```
AbslHashValue() for hashing nullptr_t

Defined at line 449 of file ../../third_party/abseil-cpp/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 455 of file ../../third_party/abseil-cpp/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 492 of file ../../third_party/abseil-cpp/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 514 of file ../../third_party/abseil-cpp/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 527 of file ../../third_party/abseil-cpp/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 533 of file ../../third_party/abseil-cpp/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 557 of file ../../third_party/abseil-cpp/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 568 of file ../../third_party/abseil-cpp/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 583 of file ../../third_party/abseil-cpp/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 603 of file ../../third_party/abseil-cpp/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 620 of file ../../third_party/abseil-cpp/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 628 of file ../../third_party/abseil-cpp/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 640 of file ../../third_party/abseil-cpp/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 652 of file ../../third_party/abseil-cpp/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 666 of file ../../third_party/abseil-cpp/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 703 of file ../../third_party/abseil-cpp/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 719 of file ../../third_party/abseil-cpp/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 731 of file ../../third_party/abseil-cpp/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 743 of file ../../third_party/abseil-cpp/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 753 of file ../../third_party/abseil-cpp/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 768 of file ../../third_party/abseil-cpp/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 778 of file ../../third_party/abseil-cpp/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 789 of file ../../third_party/abseil-cpp/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 801 of file ../../third_party/abseil-cpp/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 816 of file ../../third_party/abseil-cpp/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 823 of file ../../third_party/abseil-cpp/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 841 of file ../../third_party/abseil-cpp/absl/hash/internal/hash.h

```
uint64_t LowLevelHash (const void * data, size_t len, uint64_t seed, const uint64_t[5] salt)
```
Hash function for a byte array. A 64-bit seed and a set of five 64-bit

integers are hashed into the result.

To allow all hashable types (including string_view and Span) to depend on

this algorithm, we keep the API low-level, with as few dependencies as

possible.

uint64_t LowLevelHashLenGt16 (const void * data, size_t len, uint64_t seed, const uint64_t[5] salt)

Same as above except the length must be greater than 16.

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 82 of file ../../third_party/abseil-cpp/absl/hash/internal/hash.h
```
template <typename H, typename T>
```
```
H hash_bytes (H hash_state, const T & value)
```
hash_bytes()

Convenience function that combines `hash_state` with the byte representation

of `value`.

Defined at line 340 of file ../../third_party/abseil-cpp/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...> )
```
hash_tuple()

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 503 of file ../../third_party/abseil-cpp/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)
```
hash_range_or_bytes()

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

template <typename Htypename T>

typename std::enable_if<! is_uniquely_represented<T>::value, H>::type hash_range_or_bytes (H hash_stateconst T * datasize_t size)

hash_range_or_bytes()

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