#include <wpi/DenseMap.h>

Inheritance diagram for wpi::DenseMap< 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<typename InputIt >
	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 wpi::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<class LookupKeyT >
iterator	find_as (const LookupKeyT &Val)
	Alternate version of find() which allows a different, and possibly less expensive, key type.

template<class LookupKeyT >
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<typename LookupKeyT >
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<typename InputIt >
void	insert (InputIt I, InputIt E)
	insert - Range insertion of pairs.

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

template<typename V >
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 wpi::DebugEpochBase
	DebugEpochBase ()=default

void	incrementEpoch ()
	Calling incrementEpoch invalidates all handles pointing into the calling instance.

	~DebugEpochBase ()
	The destructor calls incrementEpoch to make use-after-free bugs more likely to crash deterministically.

Friends
class	DenseMapBase< DenseMap, KeyT, ValueT, KeyInfoT, BucketT >

Additional Inherited Members
Public Types inherited from wpi::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

Protected Member Functions inherited from wpi::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<typename OtherBaseT >
void	copyFrom (const DenseMapBase< OtherBaseT, KeyT, ValueT, KeyInfoT, BucketT > &other)

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

template<typename LookupKeyT >
static unsigned	getHashValue (const LookupKeyT &Val)

static const KeyT	getEmptyKey ()

static const KeyT	getTombstoneKey ()