llvm::StringMapImpl

Synopsis

Declared in <llvm/ADT/StringMap.h>

class StringMapImpl
    : public DebugEpochBase

Base Classes

Name	Description
`DebugEpochBase`	Empty stub of DebugEpochBase used when ABI-breaking checks are disabled.

Types

Name	Description
`HandleBase`	Empty stub of HandleBase used when ABI-breaking checks are disabled.

Member Functions

Name	Description
`empty`	Return true if the map contains no entries.
`getNumBuckets`	Return the number of allocated hash buckets.
`getNumItems`	Return the number of live entries.
`incrementEpoch`	No-op when ABI-breaking checks are disabled.
`size`	Return the number of live entries.
`swap`	Exchange the contents of this map with `Other.`

Static Member Functions

Name	Description
`hash`	Return the hash value used for `Key.`

Protected Member Functions

Name	Description
`StringMapImpl` [constructor]	Constructors
`~StringMapImpl` [destructor]	Free the hash table storage.
`FindKey`	`FindKey` overloads
`LookupBucketFor`	`LookupBucketFor` overloads
`RehashTable`	Grow and rehash the table; return the new bucket for `BucketNo.`
`RemoveKey`	`RemoveKey` overloads
`buckets`	Return a range over the raw bucket pointer array.
`init`	Allocate the table with the specified number of buckets and otherwise setup the map as empty.
`removeBucket`	Remove the entry pointer at the given (live) bucket without destroying the entry, and close the hole via Algorithm R backward shifting.

Protected Data Members

Name	Description
`ItemSize`	Size in bytes of each StringMapEntry specialization.
`NumBuckets`	Number of hash buckets currently allocated.
`NumItems`	Number of live key/value entries in the map.
`TheTable`	Hash table of entry pointers; null slots are empty probe holes.

Derived Classes

Name	Description
`StringMap`	StringMap - This is an unconventional map that is specialized for handling keys that are "strings", which are basically ranges of bytes. This does some funky memory allocation and hashing things to make it extremely efficient, storing the string data after the value in the map.
`StringMap<basic_string<char>>`	StringMap - This is an unconventional map that is specialized for handling keys that are "strings", which are basically ranges of bytes. This does some funky memory allocation and hashing things to make it extremely efficient, storing the string data after the value in the map.
`StringMap<unsigned int>`	StringMap - This is an unconventional map that is specialized for handling keys that are "strings", which are basically ranges of bytes. This does some funky memory allocation and hashing things to make it extremely efficient, storing the string data after the value in the map.
`StringMap<array<unsigned int, 5>>`	StringMap - This is an unconventional map that is specialized for handling keys that are "strings", which are basically ranges of bytes. This does some funky memory allocation and hashing things to make it extremely efficient, storing the string data after the value in the map.
`StringMap<unique_ptr<LibraryInfo>>`	StringMap - This is an unconventional map that is specialized for handling keys that are "strings", which are basically ranges of bytes. This does some funky memory allocation and hashing things to make it extremely efficient, storing the string data after the value in the map.
`StringMap<Value*>`	StringMap - This is an unconventional map that is specialized for handling keys that are "strings", which are basically ranges of bytes. This does some funky memory allocation and hashing things to make it extremely efficient, storing the string data after the value in the map.