container_internal

Namespaces

Enumerations

enum MatchKind

Name	Value
kEq	0
kNe	1

Defined at line 462 of file ../../third_party/abseil-cpp/absl/container/internal/btree.h

enum ctrl_t

Name	Value
kEmpty	-128
kDeleted	-2
kSentinel	-1

A `ctrl_t` is a single control byte, which can have one of four

states: empty, deleted, full (which has an associated seven-bit h2_t value)

and the sentinel. They have the following bit patterns:

empty: 1 0 0 0 0 0 0 0

deleted: 1 1 1 1 1 1 1 0

full: 0 h h h h h h h // h represents the hash bits.

sentinel: 1 1 1 1 1 1 1 1

These values are specifically tuned for SSE-flavored SIMD.

The static_asserts below detail the source of these choices.

We use an enum class so that when strict aliasing is enabled, the compiler

knows ctrl_t doesn't alias other types.

Defined at line 496 of file ../../third_party/abseil-cpp/absl/container/internal/raw_hash_set.h

Records

class BtreeTestOnlyCheckedCompareOptOutBase

class CommonFieldsGenerationInfoDisabled

class HashSetIteratorGenerationInfoDisabled

class HashSetIteratorGenerationInfoEnabled

class btree_iterator_generation_info_disabled

class btree_iterator_generation_info_enabled

Functions

HashtablezSampler & GlobalHashtablezSampler ()

Returns a global Sampler.

```
bool IsHashtablezEnabled ()
```
Enables or disables sampling for Swiss tables.
```
int32_t GetHashtablezSampleParameter ()
```
Sets the rate at which Swiss tables will be sampled.
```
size_t GetHashtablezMaxSamples ()
```
Sets a soft max for the number of samples that will be kept.
```
bool AbslContainerInternalSampleEverything ()
```
Configuration override.

This allows process-wide sampling without depending on order of

initialization of static storage duration objects.

The definition of this constant is weak, which allows us to inject a

different value for it at link time.
```
template <size_t Alignment, class Alloc>
```
```
void * Allocate (Alloc * alloc, size_t n)
```
Allocates at least n bytes aligned to the specified alignment.

Alignment must be a power of 2. It must be positive.

Note that many allocators don't honor alignment requirements above certain

threshold (usually either alignof(std::max_align_t) or alignof(void*)).

Allocate() doesn't apply alignment corrections. If the underlying allocator

returns insufficiently alignment pointer, that's what you are going to get.

Defined at line 55 of file ../../third_party/abseil-cpp/absl/container/internal/container_memory.h
```
void ConvertDeletedToEmptyAndFullToDeleted (ctrl_t * ctrl, size_t capacity)
```
Applies the following mapping to every byte in the control array:

* kDeleted -> kEmpty

* kEmpty -> kEmpty

* _ -> kDeleted

PRECONDITION:

IsValidCapacity(capacity)

ctrl[capacity] == ctrl_t::kSentinel

ctrl[i] != ctrl_t::kSentinel for all i

<

capacity
```
template <class Allocator, class ValueType>
```
```
auto IsDestructionTrivial ()
```
Returns true if the destruction of the value with given Allocator will be

trivial.

Defined at line 74 of file ../../third_party/abseil-cpp/absl/container/internal/container_memory.h
```
template <size_t Alignment, class Alloc>
```
```
void Deallocate (Alloc * alloc, void * p, size_t n)
```
The pointer must have been previously obtained by calling

Allocate

<Alignment

>(alloc, n).

Defined at line 86 of file ../../third_party/abseil-cpp/absl/container/internal/container_memory.h
```
bool BtreeGenerationsEnabled ()
```
Defined at line 93 of file ../../third_party/abseil-cpp/absl/container/internal/btree.h
```
void ClearBackingArray (CommonFields & c, const PolicyFunctions & policy, bool reuse)
```
ClearBackingArray clears the backing array, either modifying it in place,

or creating a new one based on the value of "reuse".

REQUIRES: c.capacity > 0
```
template <class Alloc, class T, class Tuple>
```
```
void ConstructFromTuple (Alloc * alloc, T * ptr, Tuple && t)
```
Constructs T into uninitialized storage pointed by `ptr` using the args

specified in the tuple.

Defined at line 161 of file ../../third_party/abseil-cpp/absl/container/internal/container_memory.h
```
template <class F, class S>
```
```
std::pair<std::tuple<F &&>, std::tuple<S &&>> PairArgs (F && f, S && s)
```
Defined at line 193 of file ../../third_party/abseil-cpp/absl/container/internal/container_memory.h

template <class F, class S>

std::pair<std::tuple<const F &>, std::tuple<const S &>> PairArgs (const std::pair<F, S> & p)

Defined at line 198 of file ../../third_party/abseil-cpp/absl/container/internal/container_memory.h

template <class F, class S>

std::pair<std::tuple<F &&>, std::tuple<S &&>> PairArgs (std::pair<F, S> && p)

Defined at line 203 of file ../../third_party/abseil-cpp/absl/container/internal/container_memory.h

template <class F, class S>

decltype(std::make_pair(memory_internal::TupleRef(std::forward<F>(f)), memory_internal::TupleRef(std::forward<S>(s)))) PairArgs (std::piecewise_construct_t , F && f, S && s)

Defined at line 207 of file ../../third_party/abseil-cpp/absl/container/internal/container_memory.h

template <class F, class... Args>

decltype(memory_internal::DecomposePairImpl(std::forward<F>(f), PairArgs(std::forward<Args>(args)...))) DecomposePair (F && f, Args &&... args)

A helper function for implementing apply() in map policies.

Defined at line 216 of file ../../third_party/abseil-cpp/absl/container/internal/container_memory.h

```
template <class F, class Arg>
```
```
decltype(std::declval<F>()(std::declval<const Arg &>(), std::declval<Arg>())) DecomposeValue (F && f, Arg && arg)
```
A helper function for implementing apply() in set policies.

Defined at line 225 of file ../../third_party/abseil-cpp/absl/container/internal/container_memory.h
```
GenerationType * EmptyGeneration ()
```
Returns a pointer to a generation to use for an empty hashtable.

void EraseMetaOnly (CommonFields & c, size_t index, size_t slot_size)

Type-erased version of raw_hash_set::erase_meta_only.

void DropDeletesWithoutResize (CommonFields & common, const void * hash_fn, const PolicyFunctions & policy, void * tmp_space)

Type-erased version of raw_hash_set::drop_deletes_without_resize.

```
template <class T, class Tuple, class F>
```
```
decltype(std::declval<F>()(std::declval<T>())) WithConstructed (Tuple && t, F && f)
```
Constructs T using the args specified in the tuple and calls F with the

constructed value.

Defined at line 171 of file ../../third_party/abseil-cpp/absl/container/internal/container_memory.h
```
std::pair<std::tuple<>, std::tuple<>> PairArgs ()
```
Given arguments of an std::pair's constructor, PairArgs() returns a pair of

tuples with references to the passed arguments. The tuples contain

constructor arguments for the first and the second elements of the pair.

The following two snippets are equivalent.

1. std::pair

<F

, S> p(args...);

2. auto a = PairArgs(args...);

std::pair

<F

, S> p(std::piecewise_construct,

std::move(a.first), std::move(a.second));

Defined at line 191 of file ../../third_party/abseil-cpp/absl/container/internal/container_memory.h
```
void swap (HashtablezInfoHandle & , HashtablezInfoHandle & )
```
Defined at line 198 of file ../../third_party/abseil-cpp/absl/container/internal/hashtablez_sampler.h
```
HashtablezInfoHandle Sample (size_t inline_element_size)
```
Returns an RAII sampling handle that manages registration and unregistation

with the global sampler.

Defined at line 209 of file ../../third_party/abseil-cpp/absl/container/internal/hashtablez_sampler.h
```
bool operator== (const btree_container<Tree> & x, const btree_container<Tree> & y)
```
Defined at line 231 of file ../../third_party/abseil-cpp/absl/container/internal/btree_container.h
```
void SanitizerPoisonMemoryRegion (const void * m, size_t s)
```
Helper functions for asan and msan.

Defined at line 232 of file ../../third_party/abseil-cpp/absl/container/internal/container_memory.h
```
bool operator!= (const btree_container<Tree> & x, const btree_container<Tree> & y)
```
Defined at line 236 of file ../../third_party/abseil-cpp/absl/container/internal/btree_container.h
```
bool operator< (const btree_container<Tree> & x, const btree_container<Tree> & y)
```
Defined at line 240 of file ../../third_party/abseil-cpp/absl/container/internal/btree_container.h
```
void SanitizerUnpoisonMemoryRegion (const void * m, size_t s)
```
Defined at line 243 of file ../../third_party/abseil-cpp/absl/container/internal/container_memory.h
```
bool operator> (const btree_container<Tree> & x, const btree_container<Tree> & y)
```
Defined at line 244 of file ../../third_party/abseil-cpp/absl/container/internal/btree_container.h
```
bool operator<= (const btree_container<Tree> & x, const btree_container<Tree> & y)
```
Defined at line 248 of file ../../third_party/abseil-cpp/absl/container/internal/btree_container.h
```
GenerationType SentinelEmptyGeneration ()
```
A sentinel value for empty generations. Using 0 makes it easy to constexpr

initialize an array of this value.

Defined at line 252 of file ../../third_party/abseil-cpp/absl/container/internal/raw_hash_set.h
```
bool operator>= (const btree_container<Tree> & x, const btree_container<Tree> & y)
```
Defined at line 252 of file ../../third_party/abseil-cpp/absl/container/internal/btree_container.h
```
GenerationType NextGeneration (GenerationType generation)
```
Defined at line 254 of file ../../third_party/abseil-cpp/absl/container/internal/raw_hash_set.h
```
template <typename T>
```
```
void SanitizerPoisonObject (const T * object)
```
Defined at line 255 of file ../../third_party/abseil-cpp/absl/container/internal/container_memory.h
```
template <typename T>
```
```
void SanitizerUnpoisonObject (const T * object)
```
Defined at line 260 of file ../../third_party/abseil-cpp/absl/container/internal/container_memory.h
```
bool SwisstableGenerationsEnabled ()
```
Defined at line 262 of file ../../third_party/abseil-cpp/absl/container/internal/raw_hash_set.h
```
size_t NumGenerationBytes ()
```
Defined at line 263 of file ../../third_party/abseil-cpp/absl/container/internal/raw_hash_set.h
```
template <typename State>
```
```
State AbslHashValue (State h, const btree_container<Tree> & b)
```
Support absl::Hash.

Defined at line 265 of file ../../third_party/abseil-cpp/absl/container/internal/btree_container.h

template <typename AllocType>

void SwapAlloc (AllocType & lhs, AllocType & rhs, std::true_type )

Defined at line 267 of file ../../third_party/abseil-cpp/absl/container/internal/raw_hash_set.h

template <typename AllocType>

void SwapAlloc (AllocType & lhs, AllocType & rhs, std::false_type )

Defined at line 273 of file ../../third_party/abseil-cpp/absl/container/internal/raw_hash_set.h

template <typename AllocType>

void CopyAlloc (AllocType & lhs, AllocType & rhs, std::true_type )

Defined at line 282 of file ../../third_party/abseil-cpp/absl/container/internal/raw_hash_set.h

```
template <typename AllocType>
```
```
void CopyAlloc (AllocType & , AllocType & , std::false_type )
```
Defined at line 287 of file ../../third_party/abseil-cpp/absl/container/internal/raw_hash_set.h
```
template <typename Compare, typename Key>
```
```
bool compare_has_valid_result_type ()
```
Defined at line 340 of file ../../third_party/abseil-cpp/absl/container/internal/btree.h
```
template <class T>
```
```
bool IsNoThrowSwappable (std::true_type )
```
TODO(alkis): Switch to std::is_nothrow_swappable when gcc/clang supports it.

Defined at line 362 of file ../../third_party/abseil-cpp/absl/container/internal/raw_hash_set.h
```
template <class T>
```
```
bool IsNoThrowSwappable (std::false_type )
```
Defined at line 367 of file ../../third_party/abseil-cpp/absl/container/internal/raw_hash_set.h
```
template <typename T>
```
```
uint32_t TrailingZeros (T x)
```
Defined at line 372 of file ../../third_party/abseil-cpp/absl/container/internal/raw_hash_set.h

bool operator== (const BitMask<T, SignificantBits, Shift, NullifyBitsOnIteration> & a, const BitMask<T, SignificantBits, Shift, NullifyBitsOnIteration> & b)

Defined at line 469 of file ../../third_party/abseil-cpp/absl/container/internal/raw_hash_set.h

bool operator!= (const BitMask<T, SignificantBits, Shift, NullifyBitsOnIteration> & a, const BitMask<T, SignificantBits, Shift, NullifyBitsOnIteration> & b)

Defined at line 472 of file ../../third_party/abseil-cpp/absl/container/internal/raw_hash_set.h

```
template <class Fn, class T>
```
```
size_t TypeErasedApplyToSlotFn (const void * fn, void * slot)
```
Type erased function to apply `Fn` to data inside of the `slot`.

The data is expected to have type `T`.

Defined at line 473 of file ../../third_party/abseil-cpp/absl/container/internal/container_memory.h
```
template <class Fn, class T>
```
```
size_t TypeErasedDerefAndApplyToSlotFn (const void * fn, void * slot_ptr)
```
Type erased function to apply `Fn` to data inside of the `*slot_ptr`.

The data is expected to have type `T`.

Defined at line 481 of file ../../third_party/abseil-cpp/absl/container/internal/container_memory.h
```
ctrl_t * EmptyGroup ()
```
Returns a pointer to a control byte group that can be used by empty tables.

Defined at line 532 of file ../../third_party/abseil-cpp/absl/container/internal/raw_hash_set.h
```
bool IsEmptyGeneration (const GenerationType * generation)
```
Returns whether `generation` is a generation for an empty hashtable that

could be returned by EmptyGeneration().

Defined at line 543 of file ../../third_party/abseil-cpp/absl/container/internal/raw_hash_set.h
```
template <class Mask>
```
```
auto GetInsertionOffset (Mask mask, size_t capacity, size_t hash, const ctrl_t * ctrl)
```
Returns insert position for the given mask.

We want to add entropy even when ASLR is not enabled.

In debug build we will randomly insert in either the front or back of

the group.

TODO(kfm,sbenza): revisit after we do unconditional mixing

Defined at line 558 of file ../../third_party/abseil-cpp/absl/container/internal/raw_hash_set.h
```
size_t PerTableSalt (const ctrl_t * ctrl)
```
Returns a per-table, hash salt, which changes on resize. This gets mixed into

H1 to randomize iteration order per-table.

The seed consists of the ctrl_ pointer, which adds enough entropy to ensure

non-determinism of iteration order in most cases.

Defined at line 576 of file ../../third_party/abseil-cpp/absl/container/internal/raw_hash_set.h
```
size_t H1 (size_t hash, const ctrl_t * ctrl)
```
Extracts the H1 portion of a hash: 57 bits mixed with a per-table salt.

Defined at line 583 of file ../../third_party/abseil-cpp/absl/container/internal/raw_hash_set.h
```
h2_t H2 (size_t hash)
```
Extracts the H2 portion of a hash: the 7 bits not used for H1.

These are used as an occupied control byte.

Defined at line 590 of file ../../third_party/abseil-cpp/absl/container/internal/raw_hash_set.h
```
bool IsEmpty (ctrl_t c)
```
Helpers for checking the state of a control byte.

Defined at line 593 of file ../../third_party/abseil-cpp/absl/container/internal/raw_hash_set.h
```
bool IsFull (ctrl_t c)
```
Defined at line 594 of file ../../third_party/abseil-cpp/absl/container/internal/raw_hash_set.h
```
bool IsDeleted (ctrl_t c)
```
Defined at line 597 of file ../../third_party/abseil-cpp/absl/container/internal/raw_hash_set.h
```
bool IsEmptyOrDeleted (ctrl_t c)
```
Defined at line 598 of file ../../third_party/abseil-cpp/absl/container/internal/raw_hash_set.h
```
__m128i _mm_cmpgt_epi8_fixed (__m128i a, __m128i b)
```
https://github.com/abseil/abseil-cpp/issues/209

https://gcc.gnu.org/bugzilla/show_bug.cgi?id=87853

_mm_cmpgt_epi8 is broken under GCC with -funsigned-char

Work around this by using the portable implementation of Group

when using -funsigned-char under GCC.

Defined at line 634 of file ../../third_party/abseil-cpp/absl/container/internal/raw_hash_set.h
```
size_t RehashProbabilityConstant ()
```
When there is an insertion with no reserved growth, we rehash with

probability `min(1, RehashProbabilityConstant() / capacity())`. Using a

constant divided by capacity ensures that inserting N elements is still O(N)

in the average case. Using the constant 16 means that we expect to rehash ~8

times more often than when generations are disabled. We are adding expected

rehash_probability * #insertions/capacity_growth = 16/capacity * ((7/8 -

7/16) * capacity)/capacity_growth = ~7 extra rehashes per capacity growth.

Defined at line 898 of file ../../third_party/abseil-cpp/absl/container/internal/raw_hash_set.h
```
bool IsValidCapacity (size_t n)
```
Returns whether `n` is a valid capacity (i.e., number of slots).

A valid capacity is a non-zero integer `2^m - 1`.

Defined at line 1040 of file ../../third_party/abseil-cpp/absl/container/internal/raw_hash_set.h
```
size_t NumClonedBytes ()
```
Returns the number of "cloned control bytes".

This is the number of control bytes that are present both at the beginning

of the control byte array and at the end, such that we can create a

`Group::kWidth`-width probe window starting from any control byte.

Defined at line 1047 of file ../../third_party/abseil-cpp/absl/container/internal/raw_hash_set.h
```
size_t NumControlBytes (size_t capacity)
```
Returns the number of control bytes including cloned.

Defined at line 1050 of file ../../third_party/abseil-cpp/absl/container/internal/raw_hash_set.h

template <typename Node>

bool AreNodesFromSameContainer (const Node * node_a, const Node * node_b)

Defined at line 1056 of file ../../third_party/abseil-cpp/absl/container/internal/btree.h

```
size_t NextCapacity (size_t n)
```
Returns the next valid capacity after `n`.

Defined at line 1246 of file ../../third_party/abseil-cpp/absl/container/internal/raw_hash_set.h
```
size_t NormalizeCapacity (size_t n)
```
Converts `n` into the next valid capacity, per `IsValidCapacity`.

Defined at line 1262 of file ../../third_party/abseil-cpp/absl/container/internal/raw_hash_set.h
```
size_t CapacityToGrowth (size_t capacity)
```
Given `capacity`, applies the load factor; i.e., it returns the maximum

number of values we should put into the table before a resizing rehash.

Defined at line 1276 of file ../../third_party/abseil-cpp/absl/container/internal/raw_hash_set.h
```
size_t GrowthToLowerboundCapacity (size_t growth)
```
Given `growth`, "unapplies" the load factor to find how large the capacity

should be to stay within the load factor.

This might not be a valid capacity and `NormalizeCapacity()` should be

called on this.

Defined at line 1291 of file ../../third_party/abseil-cpp/absl/container/internal/raw_hash_set.h

template <class InputIter>

size_t SelectBucketCountForIterRange (InputIter first, InputIter last, size_t bucket_count)

Defined at line 1301 of file ../../third_party/abseil-cpp/absl/container/internal/raw_hash_set.h

```
bool SwisstableDebugEnabled ()
```
Defined at line 1316 of file ../../third_party/abseil-cpp/absl/container/internal/raw_hash_set.h

void AssertIsFull (const ctrl_t * ctrl, GenerationType generation, const GenerationType * generation_ptr, const char * operation)

Defined at line 1325 of file ../../third_party/abseil-cpp/absl/container/internal/raw_hash_set.h

```
void AssertIsValidForComparison (const ctrl_t * ctrl, GenerationType generation, const GenerationType * generation_ptr)
```
Note that for comparisons, null/end iterators are valid.

Defined at line 1367 of file ../../third_party/abseil-cpp/absl/container/internal/raw_hash_set.h
```
bool AreItersFromSameContainer (const ctrl_t * ctrl_a, const ctrl_t * ctrl_b, const void *const & slot_a, const void *const & slot_b)
```
If the two iterators come from the same container, then their pointers will

interleave such that ctrl_a

<

= ctrl_b

<

slot_a

<

= slot_b or vice/versa.

Note: we take slots by reference so that it's not UB if they're uninitialized

as long as we don't read them (when ctrl is null).

Defined at line 1396 of file ../../third_party/abseil-cpp/absl/container/internal/raw_hash_set.h
```
void AssertSameContainer (const ctrl_t * ctrl_a, const ctrl_t * ctrl_b, const void *const & slot_a, const void *const & slot_b, const GenerationType * generation_ptr_a, const GenerationType * generation_ptr_b)
```
Asserts that two iterators come from the same container.

Note: we take slots by reference so that it's not UB if they're uninitialized

as long as we don't read them (when ctrl is null).

Defined at line 1414 of file ../../third_party/abseil-cpp/absl/container/internal/raw_hash_set.h
```
bool is_small (size_t capacity)
```
Whether a table is "small". A small table fits entirely into a probing

group, i.e., has a capacity

<

`Group::kWidth`.

In small mode we are able to use the whole capacity. The extra control

bytes give us at least one "empty" control byte to stop the iteration.

This is important to make 1 a valid capacity.

In small mode only the first `capacity` control bytes after the sentinel

are valid. The rest contain dummy ctrl_t::kEmpty values that do not

represent a real slot. This is important to take into account on

`find_first_non_full()`, where we never try

`ShouldInsertBackwards()` for small tables.

Defined at line 1486 of file ../../third_party/abseil-cpp/absl/container/internal/raw_hash_set.h
```
bool is_single_group (size_t capacity)
```
Whether a table fits entirely into a probing group.

Arbitrary order of elements in such tables is correct.

Defined at line 1490 of file ../../third_party/abseil-cpp/absl/container/internal/raw_hash_set.h
```
probe_seq<Group::kWidth> probe (const ctrl_t * ctrl, const size_t capacity, size_t hash)
```
Begins a probing operation on `common.control`, using `hash`.

Defined at line 1495 of file ../../third_party/abseil-cpp/absl/container/internal/raw_hash_set.h
```
probe_seq<Group::kWidth> probe (const CommonFields & common, size_t hash)
```
Defined at line 1499 of file ../../third_party/abseil-cpp/absl/container/internal/raw_hash_set.h
```
template <typename = void>
```
```
FindInfo find_first_non_full (const CommonFields & common, size_t hash)
```
Probes an array of control bits using a probe sequence derived from `hash`,

and returns the offset corresponding to the first deleted or empty slot.

Behavior when the entire table is full is undefined.

NOTE: this function must work with tables having both empty and deleted

slots in the same group. Such tables appear during `erase()`.

Defined at line 1511 of file ../../third_party/abseil-cpp/absl/container/internal/raw_hash_set.h
```
void ResetGrowthLeft (CommonFields & common)
```
Defined at line 1536 of file ../../third_party/abseil-cpp/absl/container/internal/raw_hash_set.h
```
void ResetCtrl (CommonFields & common, size_t slot_size)
```
Sets `ctrl` to `{kEmpty, kSentinel, ..., kEmpty}`, marking the entire

array as marked as empty.

Defined at line 1542 of file ../../third_party/abseil-cpp/absl/container/internal/raw_hash_set.h
```
void SetCtrl (const CommonFields & common, size_t i, ctrl_t h, size_t slot_size)
```
Sets `ctrl[i]` to `h`.

Unlike setting it directly, this function will perform bounds checks and

mirror the value to the cloned tail if necessary.

Defined at line 1555 of file ../../third_party/abseil-cpp/absl/container/internal/raw_hash_set.h
```
void SetCtrl (const CommonFields & common, size_t i, h2_t h, size_t slot_size)
```
Overload for setting to an occupied `h2_t` rather than a special `ctrl_t`.

Defined at line 1573 of file ../../third_party/abseil-cpp/absl/container/internal/raw_hash_set.h
```
size_t BackingArrayAlignment (size_t align_of_slot)
```
growth_left (which is a size_t) is stored with the backing array.

Defined at line 1579 of file ../../third_party/abseil-cpp/absl/container/internal/raw_hash_set.h
```
void * SlotAddress (void * slot_array, size_t slot, size_t slot_size)
```
Returns the address of the ith slot in slots where each slot occupies

slot_size.

Defined at line 1585 of file ../../third_party/abseil-cpp/absl/container/internal/raw_hash_set.h
```
template <class SlotType, class Callback>
```
```
void IterateOverFullSlots (const CommonFields & c, SlotType * slot, Callback cb)
```
Iterates over all full slots and calls `cb(const ctrl_t*, SlotType*)`.

NOTE: no erasure from this table allowed during Callback call.

Defined at line 1593 of file ../../third_party/abseil-cpp/absl/container/internal/raw_hash_set.h
```
template <size_t AlignOfSlot>
```
```
void DeallocateStandard (CommonFields & common, const PolicyFunctions & policy)
```
Function to place in PolicyFunctions::dealloc for raw_hash_sets

that are using std::allocator. This allows us to share the same

function body for raw_hash_set instantiations that have the

same slot alignment.

Defined at line 1912 of file ../../third_party/abseil-cpp/absl/container/internal/raw_hash_set.h
```
template <size_t SizeOfSlot>
```
```
void TransferRelocatable (void * , void * dst, void * src)
```
For trivially relocatable types we use memcpy directly. This allows us to

share the same function body for raw_hash_set instantiations that have the

same slot size as long as they are relocatable.

Defined at line 1929 of file ../../third_party/abseil-cpp/absl/container/internal/raw_hash_set.h
```
bool operator== (const iterator & a, const iterator & b)
```
Defined at line 2084 of file ../../third_party/abseil-cpp/absl/container/internal/raw_hash_set.h
```
bool operator!= (const iterator & a, const iterator & b)
```
Defined at line 2091 of file ../../third_party/abseil-cpp/absl/container/internal/raw_hash_set.h
```
bool operator== (const const_iterator & a, const const_iterator & b)
```
Defined at line 2169 of file ../../third_party/abseil-cpp/absl/container/internal/raw_hash_set.h
```
bool operator!= (const const_iterator & a, const const_iterator & b)
```
Defined at line 2172 of file ../../third_party/abseil-cpp/absl/container/internal/raw_hash_set.h

bool operator== (const raw_hash_set<Policy, Hash, Eq, Alloc> & a, const raw_hash_set<Policy, Hash, Eq, Alloc> & b)

Defined at line 2909 of file ../../third_party/abseil-cpp/absl/container/internal/raw_hash_set.h

bool operator!= (const raw_hash_set<Policy, Hash, Eq, Alloc> & a, const raw_hash_set<Policy, Hash, Eq, Alloc> & b)

Defined at line 2921 of file ../../third_party/abseil-cpp/absl/container/internal/raw_hash_set.h

template <typename H>

typename std::enable_if<H::template is_hashable<value_type>::value, H>::type AbslHashValue (H h, const raw_hash_set<Policy, Hash, Eq, Alloc> & s)

Defined at line 2926 of file ../../third_party/abseil-cpp/absl/container/internal/raw_hash_set.h

void swap (raw_hash_set<Policy, Hash, Eq, Alloc> & a, raw_hash_set<Policy, Hash, Eq, Alloc> & b)

Defined at line 2933 of file ../../third_party/abseil-cpp/absl/container/internal/raw_hash_set.h

template <typename P, typename H, typename E, typename A, typename Predicate>

typename raw_hash_set<P, H, E, A>::size_type EraseIf (Predicate & pred, raw_hash_set<P, H, E, A> * c)

Erases all elements that satisfy the predicate `pred` from the container `c`.

Defined at line 3398 of file ../../third_party/abseil-cpp/absl/container/internal/raw_hash_set.h

void RecordRehashSlow (HashtablezInfo * info, size_t total_probe_length)

void RecordReservationSlow (HashtablezInfo * info, size_t target_capacity)

void RecordClearedReservationSlow (HashtablezInfo * info)

void RecordStorageChangedSlow (HashtablezInfo * info, size_t size, size_t capacity)

void RecordInsertSlow (HashtablezInfo * info, size_t hash, size_t distance_from_desired)

void RecordEraseSlow (HashtablezInfo * info)

HashtablezInfo * SampleSlow (SamplingState & next_sample, size_t inline_element_size)

void UnsampleSlow (HashtablezInfo * info)

void SetHashtablezConfigListener (HashtablezConfigListener l)

void SetHashtablezEnabled (bool enabled)

void SetHashtablezEnabledInternal (bool enabled)

void SetHashtablezSampleParameter (int32_t rate)

void SetHashtablezSampleParameterInternal (int32_t rate)

void SetHashtablezMaxSamples (size_t max)

void SetHashtablezMaxSamplesInternal (size_t max)

```
bool ShouldInsertBackwardsForDebug (size_t capacity, size_t hash, const ctrl_t * ctrl)
```
Mixes a randomly generated per-process seed with `hash` and `ctrl` to

randomize insertion order within groups.
```
FindInfo find_first_non_full_outofline (const CommonFields & size_t )
```
Non-inlined version of find_first_non_full for use in less

performance critical routines.

Variables

const ctrl_t[32] kEmptyGroup