#include <flat_hash_map.h>

Inheritance diagram for absl::flat_hash_map< K, V, Hash, Eq, Allocator >:

Public Member Functions
	flat_hash_map ()

Public Member Functions inherited from absl::container_internal::raw_hash_map< absl::container_internal::FlatHashMapPolicy< K, V >, Hash, Eq, Allocator >
MappedReference< P >	at (const key_arg< K > &key)

MappedConstReference< P >	at (const key_arg< K > &key) const

std::pair< iterator, bool >	insert_or_assign (key_arg< K > &&k, V &&v)

std::pair< iterator, bool >	insert_or_assign (key_arg< K > &&k, const V &v)

std::pair< iterator, bool >	insert_or_assign (const key_arg< K > &k, V &&v)

std::pair< iterator, bool >	insert_or_assign (const key_arg< K > &k, const V &v)

iterator	insert_or_assign (const_iterator, key_arg< K > &&k, V &&v)

iterator	insert_or_assign (const_iterator, key_arg< K > &&k, const V &v)

iterator	insert_or_assign (const_iterator, const key_arg< K > &k, V &&v)

iterator	insert_or_assign (const_iterator, const key_arg< K > &k, const V &v)

MappedReference< P >	operator[] (key_arg< K > &&key)

MappedReference< P >	operator[] (const key_arg< K > &key)

	raw_hash_map ()

std::pair< iterator, bool >	try_emplace (key_arg< K > &&k, Args &&...args)

std::pair< iterator, bool >	try_emplace (const key_arg< K > &k, Args &&...args)

iterator	try_emplace (const_iterator, key_arg< K > &&k, Args &&...args)

iterator	try_emplace (const_iterator, const key_arg< K > &k, Args &&...args)

Public Member Functions inherited from absl::container_internal::raw_hash_set< absl::container_internal::FlatHashMapPolicy< K, V >, Hash, Eq, Allocator >
iterator	begin ()

const_iterator	begin () const

size_t	bucket_count () const

size_t	capacity () const

const_iterator	cbegin () const

const_iterator	cend () const

ABSL_ATTRIBUTE_REINITIALIZES void	clear ()

bool	contains (const key_arg< K > &key) const

size_t	count (const key_arg< K > &key) const

std::pair< iterator, bool >	emplace (Args &&...args)

std::pair< iterator, bool >	emplace (Args &&...args)

iterator	emplace_hint (const_iterator, Args &&...args)

bool	empty () const

iterator	end ()

const_iterator	end () const

std::pair< iterator, iterator >	equal_range (const key_arg< K > &key)

std::pair< const_iterator, const_iterator >	equal_range (const key_arg< K > &key) const

size_type	erase (const key_arg< K > &key)

void	erase (const_iterator cit)

void	erase (iterator it)

iterator	erase (const_iterator first, const_iterator last)

node_type	extract (const_iterator position)

node_type	extract (const key_arg< K > &key)

iterator	find (const key_arg< K > &key, size_t hash)

iterator	find (const key_arg< K > &key)

const_iterator	find (const key_arg< K > &key, size_t hash) const

const_iterator	find (const key_arg< K > &key) const

allocator_type	get_allocator () const

hasher	hash_function () const

std::pair< iterator, bool >	insert (T &&value)

std::pair< iterator, bool >	insert (const T &value)

std::pair< iterator, bool >	insert (init_type &&value)

iterator	insert (const_iterator, T &&value)

iterator	insert (const_iterator, const T &value)

iterator	insert (const_iterator, init_type &&value)

void	insert (InputIt first, InputIt last)

void	insert (std::initializer_list< T > ilist)

void	insert (std::initializer_list< init_type > ilist)

insert_return_type	insert (node_type &&node)

iterator	insert (const_iterator, node_type &&node)

key_equal	key_eq () const

iterator	lazy_emplace (const key_arg< K > &key, F &&f)

float	load_factor () const

float	max_load_factor () const

void	max_load_factor (float)

size_t	max_size () const

void	merge (raw_hash_set< absl::container_internal::FlatHashMapPolicy< K, V >, H, E, Allocator > &src)

void	merge (raw_hash_set< absl::container_internal::FlatHashMapPolicy< K, V >, H, E, Allocator > &&src)

raw_hash_set &	operator= (const raw_hash_set &that)

raw_hash_set &	operator= (raw_hash_set &&that) noexcept(absl::allocator_traits< allocator_type >::is_always_equal::value &&std::is_nothrow_move_assignable< hasher >::value &&std::is_nothrow_move_assignable< key_equal >::value)

void	prefetch (const key_arg< K > &key) const

	raw_hash_set () noexcept(std::is_nothrow_default_constructible< hasher >::value &&std::is_nothrow_default_constructible< key_equal >::value &&std::is_nothrow_default_constructible< allocator_type >::value)

	raw_hash_set (size_t bucket_count, const hasher &hash=hasher(), const key_equal &eq=key_equal(), const allocator_type &alloc=allocator_type())

	raw_hash_set (size_t bucket_count, const hasher &hash, const allocator_type &alloc)

	raw_hash_set (size_t bucket_count, const allocator_type &alloc)

	raw_hash_set (const allocator_type &alloc)

	raw_hash_set (InputIter first, InputIter last, size_t bucket_count=0, const hasher &hash=hasher(), const key_equal &eq=key_equal(), const allocator_type &alloc=allocator_type())

	raw_hash_set (InputIter first, InputIter last, size_t bucket_count, const hasher &hash, const allocator_type &alloc)

	raw_hash_set (InputIter first, InputIter last, size_t bucket_count, const allocator_type &alloc)

	raw_hash_set (InputIter first, InputIter last, const allocator_type &alloc)

	raw_hash_set (std::initializer_list< T > init, size_t bucket_count=0, const hasher &hash=hasher(), const key_equal &eq=key_equal(), const allocator_type &alloc=allocator_type())

	raw_hash_set (std::initializer_list< init_type > init, size_t bucket_count=0, const hasher &hash=hasher(), const key_equal &eq=key_equal(), const allocator_type &alloc=allocator_type())

	raw_hash_set (std::initializer_list< T > init, size_t bucket_count, const hasher &hash, const allocator_type &alloc)

	raw_hash_set (std::initializer_list< init_type > init, size_t bucket_count, const hasher &hash, const allocator_type &alloc)

	raw_hash_set (std::initializer_list< T > init, size_t bucket_count, const allocator_type &alloc)

	raw_hash_set (std::initializer_list< init_type > init, size_t bucket_count, const allocator_type &alloc)

	raw_hash_set (std::initializer_list< T > init, const allocator_type &alloc)

	raw_hash_set (std::initializer_list< init_type > init, const allocator_type &alloc)

	raw_hash_set (const raw_hash_set &that)

	raw_hash_set (const raw_hash_set &that, const allocator_type &a)

	raw_hash_set (raw_hash_set &&that) noexcept(std::is_nothrow_copy_constructible< hasher >::value &&std::is_nothrow_copy_constructible< key_equal >::value &&std::is_nothrow_copy_constructible< allocator_type >::value)

	raw_hash_set (raw_hash_set &&that, const allocator_type &a)

void	rehash (size_t n)

void	reserve (size_t n)

size_t	size () const

void	swap (raw_hash_set &that) noexcept(IsNoThrowSwappable< hasher >()&&IsNoThrowSwappable< key_equal >()&&(!AllocTraits::propagate_on_container_swap::value\|\|IsNoThrowSwappable< allocator_type >()))

	~raw_hash_set ()

Private Types
using	Base = typename flat_hash_map::raw_hash_map

Additional Inherited Members
Public Types inherited from absl::container_internal::raw_hash_map< absl::container_internal::FlatHashMapPolicy< K, V >, Hash, Eq, Allocator >
using	const_iterator = typename raw_hash_map::raw_hash_set::const_iterator

using	iterator = typename raw_hash_map::raw_hash_set::iterator

using	key_arg = typename KeyArgImpl::template type< K, key_type >

using	key_type = typename absl::container_internal::FlatHashMapPolicy< K, V >::key_type

using	mapped_type = typename absl::container_internal::FlatHashMapPolicy< K, V >::mapped_type

Public Types inherited from absl::container_internal::raw_hash_set< absl::container_internal::FlatHashMapPolicy< K, V >, Hash, Eq, Allocator >
using	allocator_type = Allocator

using	const_pointer = typename absl::allocator_traits< allocator_type >::template rebind_traits< value_type >::const_pointer

using	const_reference = const value_type &

using	difference_type = ptrdiff_t

using	hasher = Hash

using	init_type = typename PolicyTraits::init_type

using	insert_return_type = InsertReturnType< iterator, node_type >

using	key_arg = typename KeyArgImpl::template type< K, key_type >

using	key_equal = Eq

using	key_type = typename PolicyTraits::key_type

using	node_type = node_handle< absl::container_internal::FlatHashMapPolicy< K, V >, hash_policy_traits< absl::container_internal::FlatHashMapPolicy< K, V > >, Allocator >

using	pointer = typename absl::allocator_traits< allocator_type >::template rebind_traits< value_type >::pointer

using	policy_type = absl::container_internal::FlatHashMapPolicy< K, V >

using	reference = value_type &

using	size_type = size_t

using	slot_type = typename PolicyTraits::slot_type

using	value_type = typename PolicyTraits::value_type

Protected Member Functions inherited from absl::container_internal::raw_hash_set< absl::container_internal::FlatHashMapPolicy< K, V >, Hash, Eq, Allocator >
void	emplace_at (size_t i, Args &&...args)

std::pair< size_t, bool >	find_or_prepare_insert (const K &key)

iterator	iterator_at (size_t i)

const_iterator	iterator_at (size_t i) const

size_t	prepare_insert (size_t hash) ABSL_ATTRIBUTE_NOINLINE

Detailed Description

template<class K, class V, class Hash = absl::container_internal::hash_default_hash<K>, class Eq = absl::container_internal::hash_default_eq<K>, class Allocator = std::allocator<std::pair<const K, V>>>
class absl::flat_hash_map< K, V, Hash, Eq, Allocator >

Definition at line 107 of file flat_hash_map.h.

Member Typedef Documentation

template<class K, class V, class Hash = absl::container_internal::hash_default_hash<K>, class Eq = absl::container_internal::hash_default_eq<K>, class Allocator = std::allocator<std::pair<const K, V>>>

using absl::flat_hash_map< K, V, Hash, Eq, Allocator >::Base = typename flat_hash_map::raw_hash_map

private

Definition at line 110 of file flat_hash_map.h.

Constructor & Destructor Documentation

template<class K, class V, class Hash = absl::container_internal::hash_default_hash<K>, class Eq = absl::container_internal::hash_default_eq<K>, class Allocator = std::allocator<std::pair<const K, V>>>

absl::flat_hash_map< K, V, Hash, Eq, Allocator >::flat_hash_map ( )

inline

Definition at line 153 of file flat_hash_map.h.

The documentation for this class was generated from the following file:

flat_hash_map.h

Public Member Functions

Private Types

Additional Inherited Members

Detailed Description

template<class K, class V, class Hash = absl::container_internal::hash_default_hash<K>, class Eq = absl::container_internal::hash_default_eq<K>, class Allocator = std::allocator<std::pair<const K, V>>> class absl::flat_hash_map< K, V, Hash, Eq, Allocator >

Member Typedef Documentation

Constructor & Destructor Documentation

template<class K, class V, class Hash = absl::container_internal::hash_default_hash<K>, class Eq = absl::container_internal::hash_default_eq<K>, class Allocator = std::allocator<std::pair<const K, V>>>
class absl::flat_hash_map< K, V, Hash, Eq, Allocator >