LLVM: llvm::DenseMap< KeyT, ValueT, KeyInfoT, BucketT (original) (raw)

#include "[llvm/ADT/DenseMap.h](DenseMap%5F8h%5Fsource.html)"

Inherits llvm::DenseMapBase< DerivedT, KeyT, ValueT, KeyInfoT, BucketT >.

Public Member Functions
	DenseMap (unsigned InitialReserve=0)
	Create a DenseMap with an optional InitialReserve that guarantee that this number of elements can be inserted in the map without grow()

	DenseMap (const DenseMap &other)

	DenseMap (DenseMap &&other)

template
	DenseMap (const InputIt &I, const InputIt &E)

	DenseMap (std::initializer_list< typename BaseT::value_type > Vals)

	~DenseMap ()

void	swap (DenseMap &RHS)

DenseMap &	operator= (const DenseMap &other)

DenseMap &	operator= (DenseMap &&other)

void	copyFrom (const DenseMap &other)

void	init (unsigned InitNumEntries)

void	grow (unsigned AtLeast)

void	shrink_and_clear ()

Public Member Functions inherited from llvm::DenseMapBase< DerivedT, KeyT, ValueT, KeyInfoT, BucketT >
iterator	begin ()

iterator	end ()

const_iterator	begin () const

const_iterator	end () const

bool	empty () const

unsigned	size () const

void	reserve (size_type NumEntries)
	Grow the densemap so that it can contain at least NumEntries items before resizing again.

void	clear ()

bool	contains (const_arg_type_t< KeyT > Val) const
	Return true if the specified key is in the map, false otherwise.

size_type	count (const_arg_type_t< KeyT > Val) const
	Return 1 if the specified key is in the map, 0 otherwise.

iterator	find (const_arg_type_t< KeyT > Val)

const_iterator	find (const_arg_type_t< KeyT > Val) const

template
iterator	find_as (const LookupKeyT &Val)
	Alternate version of find() which allows a different, and possibly less expensive, key type.

template
const_iterator	find_as (const LookupKeyT &Val) const

ValueT	lookup (const_arg_type_t< KeyT > Val) const
	lookup - Return the entry for the specified key, or a default constructed value if no such entry exists.

const ValueT &	at (const_arg_type_t< KeyT > Val) const
	at - Return the entry for the specified key, or abort if no such entry exists.

std::pair< iterator, bool >	insert (const std::pair< KeyT, ValueT > &KV)

std::pair< iterator, bool >	insert (std::pair< KeyT, ValueT > &&KV)

template<typename... Ts>
std::pair< iterator, bool >	try_emplace (KeyT &&Key, Ts &&...Args)

template<typename... Ts>
std::pair< iterator, bool >	try_emplace (const KeyT &Key, Ts &&...Args)

template
std::pair< iterator, bool >	insert_as (std::pair< KeyT, ValueT > &&KV, const LookupKeyT &Val)
	Alternate version of insert() which allows a different, and possibly less expensive, key type.

template
void	insert (InputIt I, InputIt E)
	insert - Range insertion of pairs.

template
std::pair< iterator, bool >	insert_or_assign (const KeyT &Key, V &&Val)

template
std::pair< iterator, bool >	insert_or_assign (KeyT &&Key, V &&Val)

bool	erase (const KeyT &Val)

void	erase (iterator I)

ValueT &	operator[] (const KeyT &Key)

ValueT &	operator[] (KeyT &&Key)

bool	isPointerIntoBucketsArray (const void *Ptr) const
	isPointerIntoBucketsArray - Return true if the specified pointer points somewhere into the DenseMap's array of buckets (i.e.

const void *	getPointerIntoBucketsArray () const
	getPointerIntoBucketsArray() - Return an opaque pointer into the buckets array.

size_t	getMemorySize () const
	Return the approximate size (in bytes) of the actual map.

Public Member Functions inherited from llvm::DebugEpochBase
void	incrementEpoch ()

Additional Inherited Members
Public Types inherited from llvm::DenseMapBase< DerivedT, KeyT, ValueT, KeyInfoT, BucketT >
using	size_type = unsigned

using	key_type = KeyT

using	mapped_type = ValueT

using	value_type = BucketT

using	iterator = DenseMapIterator< KeyT, ValueT, KeyInfoT, BucketT >

using	const_iterator = DenseMapIterator< KeyT, ValueT, KeyInfoT, BucketT, true >

Protected Member Functions inherited from llvm::DenseMapBase< DerivedT, KeyT, ValueT, KeyInfoT, BucketT >
	DenseMapBase ()=default

void	destroyAll ()

void	initEmpty ()

unsigned	getMinBucketToReserveForEntries (unsigned NumEntries)
	Returns the number of buckets to allocate to ensure that the DenseMap can accommodate NumEntries without need to grow().

void	moveFromOldBuckets (BucketT OldBucketsBegin, BucketT OldBucketsEnd)

template
void	copyFrom (const DenseMapBase< OtherBaseT, KeyT, ValueT, KeyInfoT, BucketT > &other)

Static Protected Member Functions inherited from llvm::DenseMapBase< DerivedT, KeyT, ValueT, KeyInfoT, BucketT >
static unsigned	getHashValue (const KeyT &Val)

template
static unsigned	getHashValue (const LookupKeyT &Val)

static const KeyT	getEmptyKey ()

static const KeyT	getTombstoneKey ()

template<typename KeyT, typename ValueT, typename KeyInfoT = DenseMapInfo, typename BucketT = llvm::detail::DenseMapPair<KeyT, ValueT>>
class llvm::DenseMap< KeyT, ValueT, KeyInfoT, BucketT >

Definition at line 726 of file DenseMap.h.