A unordered_map class in which aterms can be stored. More...

#include <unordered_map.h>

Inheritance diagram for atermpp::unordered_map< Key, T, Hash, Pred, Alloc >:

Public Types
typedef super::allocator_type	allocator_type
	Standard typedefs.

typedef super::value_type	value_type

typedef super::size_type	size_type

typedef super::node_type	node_type

typedef super::reference	reference

typedef super::iterator	iterator

typedef super::const_iterator	const_iterator

typedef super::insert_return_type	insert_return_type

Public Member Functions
	unordered_map ()
	Default constructor.

	unordered_map (const allocator_type &alloc)
	Constructor.

	unordered_map (size_type n, const allocator_type &alloc=allocator_type())
	Constructor.

	unordered_map (size_type n, const value_type &val, const allocator_type &alloc=allocator_type())

template<class InputIterator >
	unordered_map (InputIterator first, InputIterator last, const allocator_type &alloc=allocator_type())
	Constructor.

	unordered_map (const unordered_map &x)
	Constructor.

	unordered_map (const unordered_map &x, const allocator_type &alloc)
	Constructor.

	unordered_map (unordered_map &&x)
	Constructor.

	unordered_map (unordered_map &&x, const allocator_type &alloc)
	Constructor.

	unordered_map (std::initializer_list< value_type > il, const allocator_type &alloc=allocator_type())
	Constructor. To be done later....

unordered_map &	operator= (const unordered_map &other)=default
	Standard assignment.

unordered_map &	operator= (unordered_map &&other)=default
	Standard move assignment.

	~unordered_map ()=default
	Standard destructor.

void	clear () noexcept

std::pair< iterator, bool >	insert (const value_type &value)
	Inserts an element referring to a default value in the map.

template<class P >
std::pair< iterator, bool >	insert (P &&value)

iterator	insert (const_iterator hint, const value_type &value)

template<class P >
iterator	insert (const_iterator hint, P &&value)

template<class InputIt >
void	insert (InputIt first, InputIt last)

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

insert_return_type	insert (node_type &&nh)

iterator	insert (const_iterator hint, node_type &&nh)

template<class M >
std::pair< iterator, bool >	insert_or_assign (const Key &k, M &&obj)

template<class M >
std::pair< iterator, bool >	insert_or_assign (Key &&k, M &&obj)

template<class M >
iterator	insert_or_assign (const_iterator hint, const Key &k, M &&obj)

template<class M >
iterator	insert_or_assign (const_iterator hint, Key &&k, M &&obj)

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

template<class... Args>
iterator	emplace_hint (const_iterator hint, Args &&... args)

template<class... Args>
std::pair< iterator, bool >	try_emplace (const Key &k, Args &&... args)

template<class... Args>
std::pair< iterator, bool >	try_emplace (Key &&k, Args &&... args)

template<class... Args>
iterator	try_emplace (const_iterator hint, const Key &k, Args &&... args)

template<class... Args>
iterator	try_emplace (const_iterator hint, Key &&k, Args &&... args)

iterator	erase (iterator pos)

iterator	erase (const_iterator pos)

iterator	erase (const_iterator first, const_iterator last)

size_type	erase (const Key &key)

void	swap (unordered_map &other)

node_type	extract (const_iterator position)

node_type	extract (const Key &k)

template<class H2 , class P2 >
void	merge (std::unordered_map< Key, T, H2, P2, allocator_type > &source)

template<class H2 , class P2 >
void	merge (std::unordered_map< Key, T, H2, P2, allocator_type > &&source)

template<class H2 , class P2 >
void	merge (std::unordered_multimap< Key, T, H2, P2, allocator_type > &source)

template<class H2 , class P2 >
void	merge (std::unordered_multimap< Key, T, H2, P2, allocator_type > &&source)

std::size_t	size () const

iterator	begin ()

iterator	end ()

const_iterator	begin () const

const_iterator	end () const

const_iterator	cbegin () const

const_iterator	cend () const

bool	empty () const noexcept

size_type	max_size () const noexcept

template<class P >
std::pair< typename unordered_map< Key, T, Hash, Pred, Alloc >::iterator, bool >	insert (P &&value)

template<class M >
std::pair< typename unordered_map< Key, T, Hash, Pred, Alloc >::iterator, bool >	insert_or_assign (const Key &k, M &&obj)

template<class M >
std::pair< typename unordered_map< Key, T, Hash, Pred, Alloc >::iterator, bool >	insert_or_assign (Key &&k, M &&obj)

template<class... Args>
std::pair< typename unordered_map< Key, T, Hash, Pred, Alloc >::iterator, bool >	emplace (Args &&... args)

template<class... Args>
std::pair< typename unordered_map< Key, T, Hash, Pred, Alloc >::iterator, bool >	try_emplace (const Key &k, Args &&... args)

template<class... Args>
std::pair< typename unordered_map< Key, T, Hash, Pred, Alloc >::iterator, bool >	try_emplace (Key &&k, Args &&... args)

template<class P >
std::pair< typename unordered_map< Key, T, Hash, Pred, Alloc, ThreadSafe >::iterator, bool >	insert (P &&value)

template<class M >
std::pair< typename unordered_map< Key, T, Hash, Pred, Alloc, ThreadSafe >::iterator, bool >	insert_or_assign (const Key &k, M &&obj)

template<class M >
std::pair< typename unordered_map< Key, T, Hash, Pred, Alloc, ThreadSafe >::iterator, bool >	insert_or_assign (Key &&k, M &&obj)

template<class... Args>
std::pair< typename unordered_map< Key, T, Hash, Pred, Alloc, ThreadSafe >::iterator, bool >	emplace (Args &&... args)

template<class... Args>
std::pair< typename unordered_map< Key, T, Hash, Pred, Alloc, ThreadSafe >::iterator, bool >	try_emplace (const Key &k, Args &&... args)

template<class... Args>
std::pair< typename unordered_map< Key, T, Hash, Pred, Alloc, ThreadSafe >::iterator, bool >	try_emplace (Key &&k, Args &&... args)

Protected Types
typedef std::unordered_map< detail::reference_aterm< Key >, detail::reference_aterm< T >, Hash, Pred, Alloc >	super

Protected Attributes
detail::generic_aterm_container< std::unordered_map< detail::reference_aterm< Key >, detail::reference_aterm< T >, Hash, Pred, Alloc > >	container_wrapper

Detailed Description

template<class Key, class T, class Hash = std::hash<detail::reference_aterm<Key> >, class Pred = std::equal_to<detail::reference_aterm<Key> >, class Alloc = std::allocator< std::pair<const detail::reference_aterm<Key>, detail::reference_aterm<T> > >>
class atermpp::unordered_map< Key, T, Hash, Pred, Alloc >

A unordered_map class in which aterms can be stored.

Definition at line 37 of file unordered_map.h.

Member Typedef Documentation

◆ allocator_type

template<class Key , class T , class Hash = std::hash<detail::reference_aterm<Key> >, class Pred = std::equal_to<detail::reference_aterm<Key> >, class Alloc = std::allocator< std::pair<const detail::reference_aterm<Key>, detail::reference_aterm<T> > >>

typedef super::allocator_type atermpp::unordered_map< Key, T, Hash, Pred, Alloc >::allocator_type

Standard typedefs.

Definition at line 47 of file unordered_map.h.

◆ const_iterator

template<class Key , class T , class Hash = std::hash<detail::reference_aterm<Key> >, class Pred = std::equal_to<detail::reference_aterm<Key> >, class Alloc = std::allocator< std::pair<const detail::reference_aterm<Key>, detail::reference_aterm<T> > >>

typedef super::const_iterator atermpp::unordered_map< Key, T, Hash, Pred, Alloc >::const_iterator

Definition at line 53 of file unordered_map.h.

◆ insert_return_type

template<class Key , class T , class Hash = std::hash<detail::reference_aterm<Key> >, class Pred = std::equal_to<detail::reference_aterm<Key> >, class Alloc = std::allocator< std::pair<const detail::reference_aterm<Key>, detail::reference_aterm<T> > >>

typedef super::insert_return_type atermpp::unordered_map< Key, T, Hash, Pred, Alloc >::insert_return_type

Definition at line 54 of file unordered_map.h.

◆ iterator

template<class Key , class T , class Hash = std::hash<detail::reference_aterm<Key> >, class Pred = std::equal_to<detail::reference_aterm<Key> >, class Alloc = std::allocator< std::pair<const detail::reference_aterm<Key>, detail::reference_aterm<T> > >>

typedef super::iterator atermpp::unordered_map< Key, T, Hash, Pred, Alloc >::iterator

Definition at line 52 of file unordered_map.h.

◆ node_type

template<class Key , class T , class Hash = std::hash<detail::reference_aterm<Key> >, class Pred = std::equal_to<detail::reference_aterm<Key> >, class Alloc = std::allocator< std::pair<const detail::reference_aterm<Key>, detail::reference_aterm<T> > >>

typedef super::node_type atermpp::unordered_map< Key, T, Hash, Pred, Alloc >::node_type

Definition at line 50 of file unordered_map.h.

◆ reference

template<class Key , class T , class Hash = std::hash<detail::reference_aterm<Key> >, class Pred = std::equal_to<detail::reference_aterm<Key> >, class Alloc = std::allocator< std::pair<const detail::reference_aterm<Key>, detail::reference_aterm<T> > >>

typedef super::reference atermpp::unordered_map< Key, T, Hash, Pred, Alloc >::reference

Definition at line 51 of file unordered_map.h.

◆ size_type

template<class Key , class T , class Hash = std::hash<detail::reference_aterm<Key> >, class Pred = std::equal_to<detail::reference_aterm<Key> >, class Alloc = std::allocator< std::pair<const detail::reference_aterm<Key>, detail::reference_aterm<T> > >>

typedef super::size_type atermpp::unordered_map< Key, T, Hash, Pred, Alloc >::size_type

Definition at line 49 of file unordered_map.h.

◆ super

template<class Key , class T , class Hash = std::hash<detail::reference_aterm<Key> >, class Pred = std::equal_to<detail::reference_aterm<Key> >, class Alloc = std::allocator< std::pair<const detail::reference_aterm<Key>, detail::reference_aterm<T> > >>

typedef std::unordered_map< detail::reference_aterm<Key>, detail::reference_aterm<T>, Hash, Pred, Alloc > atermpp::unordered_map< Key, T, Hash, Pred, Alloc >::super

protected

Definition at line 40 of file unordered_map.h.

◆ value_type

template<class Key , class T , class Hash = std::hash<detail::reference_aterm<Key> >, class Pred = std::equal_to<detail::reference_aterm<Key> >, class Alloc = std::allocator< std::pair<const detail::reference_aterm<Key>, detail::reference_aterm<T> > >>

typedef super::value_type atermpp::unordered_map< Key, T, Hash, Pred, Alloc >::value_type

Definition at line 48 of file unordered_map.h.

Constructor & Destructor Documentation

◆ unordered_map() [1/10]

template<class Key , class T , class Hash = std::hash<detail::reference_aterm<Key> >, class Pred = std::equal_to<detail::reference_aterm<Key> >, class Alloc = std::allocator< std::pair<const detail::reference_aterm<Key>, detail::reference_aterm<T> > >>

atermpp::unordered_map< Key, T, Hash, Pred, Alloc >::unordered_map ( )

inline

Default constructor.

Definition at line 57 of file unordered_map.h.

◆ unordered_map() [2/10]

template<class Key , class T , class Hash = std::hash<detail::reference_aterm<Key> >, class Pred = std::equal_to<detail::reference_aterm<Key> >, class Alloc = std::allocator< std::pair<const detail::reference_aterm<Key>, detail::reference_aterm<T> > >>

atermpp::unordered_map< Key, T, Hash, Pred, Alloc >::unordered_map ( const allocator_type & alloc )

inlineexplicit

Constructor.

Definition at line 63 of file unordered_map.h.

◆ unordered_map() [3/10]

template<class Key , class T , class Hash = std::hash<detail::reference_aterm<Key> >, class Pred = std::equal_to<detail::reference_aterm<Key> >, class Alloc = std::allocator< std::pair<const detail::reference_aterm<Key>, detail::reference_aterm<T> > >>

atermpp::unordered_map< Key, T, Hash, Pred, Alloc >::unordered_map	(	size_type	n,
		const allocator_type &	alloc = `allocator_type()`
	)

inlineexplicit

Constructor.

Definition at line 69 of file unordered_map.h.

◆ unordered_map() [4/10]

template<class Key , class T , class Hash = std::hash<detail::reference_aterm<Key> >, class Pred = std::equal_to<detail::reference_aterm<Key> >, class Alloc = std::allocator< std::pair<const detail::reference_aterm<Key>, detail::reference_aterm<T> > >>

atermpp::unordered_map< Key, T, Hash, Pred, Alloc >::unordered_map	(	size_type	n,
		const value_type &	val,
		const allocator_type &	alloc = `allocator_type()`
	)

inline

Definition at line 74 of file unordered_map.h.

◆ unordered_map() [5/10]

template<class Key , class T , class Hash = std::hash<detail::reference_aterm<Key> >, class Pred = std::equal_to<detail::reference_aterm<Key> >, class Alloc = std::allocator< std::pair<const detail::reference_aterm<Key>, detail::reference_aterm<T> > >>

template<class InputIterator >

atermpp::unordered_map< Key, T, Hash, Pred, Alloc >::unordered_map	(	InputIterator	first,
		InputIterator	last,
		const allocator_type &	alloc = `allocator_type()`
	)

inline

Constructor.

Definition at line 81 of file unordered_map.h.

◆ unordered_map() [6/10]

template<class Key , class T , class Hash = std::hash<detail::reference_aterm<Key> >, class Pred = std::equal_to<detail::reference_aterm<Key> >, class Alloc = std::allocator< std::pair<const detail::reference_aterm<Key>, detail::reference_aterm<T> > >>

atermpp::unordered_map< Key, T, Hash, Pred, Alloc >::unordered_map ( const unordered_map< Key, T, Hash, Pred, Alloc > & x )

inline

Constructor.

Definition at line 87 of file unordered_map.h.

◆ unordered_map() [7/10]

template<class Key , class T , class Hash = std::hash<detail::reference_aterm<Key> >, class Pred = std::equal_to<detail::reference_aterm<Key> >, class Alloc = std::allocator< std::pair<const detail::reference_aterm<Key>, detail::reference_aterm<T> > >>

atermpp::unordered_map< Key, T, Hash, Pred, Alloc >::unordered_map	(	const unordered_map< Key, T, Hash, Pred, Alloc > &	x,
		const allocator_type &	alloc
	)

inline

Constructor.

Definition at line 93 of file unordered_map.h.

◆ unordered_map() [8/10]

template<class Key , class T , class Hash = std::hash<detail::reference_aterm<Key> >, class Pred = std::equal_to<detail::reference_aterm<Key> >, class Alloc = std::allocator< std::pair<const detail::reference_aterm<Key>, detail::reference_aterm<T> > >>

atermpp::unordered_map< Key, T, Hash, Pred, Alloc >::unordered_map ( unordered_map< Key, T, Hash, Pred, Alloc > && x )

inline

Constructor.

Definition at line 99 of file unordered_map.h.

◆ unordered_map() [9/10]

template<class Key , class T , class Hash = std::hash<detail::reference_aterm<Key> >, class Pred = std::equal_to<detail::reference_aterm<Key> >, class Alloc = std::allocator< std::pair<const detail::reference_aterm<Key>, detail::reference_aterm<T> > >>

atermpp::unordered_map< Key, T, Hash, Pred, Alloc >::unordered_map	(	unordered_map< Key, T, Hash, Pred, Alloc > &&	x,
		const allocator_type &	alloc
	)

inline

Constructor.

Definition at line 106 of file unordered_map.h.

◆ unordered_map() [10/10]

template<class Key , class T , class Hash = std::hash<detail::reference_aterm<Key> >, class Pred = std::equal_to<detail::reference_aterm<Key> >, class Alloc = std::allocator< std::pair<const detail::reference_aterm<Key>, detail::reference_aterm<T> > >>

atermpp::unordered_map< Key, T, Hash, Pred, Alloc >::unordered_map	(	std::initializer_list< value_type >	il,
		const allocator_type &	alloc = `allocator_type()`
	)

inline

Constructor. To be done later....

Definition at line 112 of file unordered_map.h.

◆ ~unordered_map()

template<class Key , class T , class Hash = std::hash<detail::reference_aterm<Key> >, class Pred = std::equal_to<detail::reference_aterm<Key> >, class Alloc = std::allocator< std::pair<const detail::reference_aterm<Key>, detail::reference_aterm<T> > >>

atermpp::unordered_map< Key, T, Hash, Pred, Alloc >::~unordered_map ( )

default

Standard destructor.

Member Function Documentation

◆ begin() [1/2]

template<class Key , class T , class Hash , class Pred , class Alloc >

unordered_map< Key, T, Hash, Pred, Alloc >::iterator atermpp::unordered_map< Key, T, Hash, Pred, Alloc >::begin

inline

Returns: An iterator over all keys.

Definition at line 253 of file unordered_map_implementation.h.

◆ begin() [2/2]

template<class Key , class T , class Hash , class Pred , class Alloc >

unordered_map< Key, T, Hash, Pred, Alloc >::const_iterator atermpp::unordered_map< Key, T, Hash, Pred, Alloc >::begin

Returns: A const iterator over all keys.

Definition at line 267 of file unordered_map_implementation.h.

◆ cbegin()

template<class Key , class T , class Hash , class Pred , class Alloc >

unordered_map< Key, T, Hash, Pred, Alloc >::const_iterator atermpp::unordered_map< Key, T, Hash, Pred, Alloc >::cbegin

Returns: A const iterator over all keys.

Definition at line 281 of file unordered_map_implementation.h.

◆ cend()

template<class Key , class T , class Hash , class Pred , class Alloc >

unordered_map< Key, T, Hash, Pred, Alloc >::const_iterator atermpp::unordered_map< Key, T, Hash, Pred, Alloc >::cend

Definition at line 288 of file unordered_map_implementation.h.

◆ clear()

template<class Key , class T , class Hash , class Pred , class Alloc >

void atermpp::unordered_map< Key, T, Hash, Pred, Alloc >::clear

noexcept

Definition at line 25 of file unordered_map_implementation.h.

◆ emplace() [1/3]

template<class Key , class T , class Hash = std::hash<detail::reference_aterm<Key> >, class Pred = std::equal_to<detail::reference_aterm<Key> >, class Alloc = std::allocator< std::pair<const detail::reference_aterm<Key>, detail::reference_aterm<T> > >>

template<class... Args>

std::pair< typename unordered_map< Key, T, Hash, Pred, Alloc >::iterator, bool > atermpp::unordered_map< Key, T, Hash, Pred, Alloc >::emplace ( Args &&... args )

Definition at line 125 of file unordered_map_implementation.h.

◆ emplace() [2/3]

template<class Key , class T , class Hash = std::hash<detail::reference_aterm<Key> >, class Pred = std::equal_to<detail::reference_aterm<Key> >, class Alloc = std::allocator< std::pair<const detail::reference_aterm<Key>, detail::reference_aterm<T> > >>

template<class... Args>

std::pair< typename unordered_map< Key, T, Hash, Pred, Alloc, ThreadSafe >::iterator, bool > atermpp::unordered_map< Key, T, Hash, Pred, Alloc >::emplace ( Args &&... args )

Definition at line 475 of file unordered_map_implementation.h.

◆ emplace() [3/3]

template<class Key , class T , class Hash = std::hash<detail::reference_aterm<Key> >, class Pred = std::equal_to<detail::reference_aterm<Key> >, class Alloc = std::allocator< std::pair<const detail::reference_aterm<Key>, detail::reference_aterm<T> > >>

template<class... Args>

std::pair< iterator, bool > atermpp::unordered_map< Key, T, Hash, Pred, Alloc >::emplace ( Args &&... args )

◆ emplace_hint()

template<class Key , class T , class Hash , class Pred , class Alloc >

template<class... Args>

unordered_map< Key, T, Hash, Pred, Alloc >::iterator atermpp::unordered_map< Key, T, Hash, Pred, Alloc >::emplace_hint	(	const_iterator	hint,
		Args &&...	args
	)

Definition at line 133 of file unordered_map_implementation.h.

◆ empty()

template<class Key , class T , class Hash , class Pred , class Alloc >

bool atermpp::unordered_map< Key, T, Hash, Pred, Alloc >::empty

noexcept

Returns: True iff the set is empty.

Definition at line 295 of file unordered_map_implementation.h.

◆ end() [1/2]

template<class Key , class T , class Hash , class Pred , class Alloc >

unordered_map< Key, T, Hash, Pred, Alloc >::iterator atermpp::unordered_map< Key, T, Hash, Pred, Alloc >::end

inline

Definition at line 260 of file unordered_map_implementation.h.

◆ end() [2/2]

template<class Key , class T , class Hash , class Pred , class Alloc >

unordered_map< Key, T, Hash, Pred, Alloc >::const_iterator atermpp::unordered_map< Key, T, Hash, Pred, Alloc >::end

Definition at line 274 of file unordered_map_implementation.h.

◆ erase() [1/4]

template<class Key , class T , class Hash , class Pred , class Alloc >

unordered_map< Key, T, Hash, Pred, Alloc >::size_type atermpp::unordered_map< Key, T, Hash, Pred, Alloc >::erase ( const Key & key )

Definition at line 193 of file unordered_map_implementation.h.

◆ erase() [2/4]

template<class Key , class T , class Hash , class Pred , class Alloc >

unordered_map< Key, T, Hash, Pred, Alloc >::iterator atermpp::unordered_map< Key, T, Hash, Pred, Alloc >::erase	(	const_iterator	first,
		const_iterator	last
	)

Definition at line 186 of file unordered_map_implementation.h.

◆ erase() [3/4]

template<class Key , class T , class Hash , class Pred , class Alloc >

unordered_map< Key, T, Hash, Pred, Alloc >::iterator atermpp::unordered_map< Key, T, Hash, Pred, Alloc >::erase ( const_iterator pos )

Definition at line 179 of file unordered_map_implementation.h.

◆ erase() [4/4]

template<class Key , class T , class Hash , class Pred , class Alloc >

unordered_map< Key, T, Hash, Pred, Alloc >::iterator atermpp::unordered_map< Key, T, Hash, Pred, Alloc >::erase ( iterator pos )

Definition at line 172 of file unordered_map_implementation.h.

◆ extract() [1/2]

template<class Key , class T , class Hash , class Pred , class Alloc >

unordered_map< Key, T, Hash, Pred, Alloc >::node_type atermpp::unordered_map< Key, T, Hash, Pred, Alloc >::extract ( const Key & k )

Definition at line 214 of file unordered_map_implementation.h.

◆ extract() [2/2]

template<class Key , class T , class Hash , class Pred , class Alloc >

unordered_map< Key, T, Hash, Pred, Alloc >::node_type atermpp::unordered_map< Key, T, Hash, Pred, Alloc >::extract ( const_iterator position )

Definition at line 207 of file unordered_map_implementation.h.

◆ insert() [1/10]

template<class Key , class T , class Hash , class Pred , class Alloc >

std::pair< typename unordered_map< Key, T, Hash, Pred, Alloc >::iterator, bool > atermpp::unordered_map< Key, T, Hash, Pred, Alloc >::insert ( const value_type & value )

Inserts an element referring to a default value in the map.

Definition at line 33 of file unordered_map_implementation.h.

◆ insert() [2/10]

template<class Key , class T , class Hash , class Pred , class Alloc >

unordered_map< Key, T, Hash, Pred, Alloc >::iterator atermpp::unordered_map< Key, T, Hash, Pred, Alloc >::insert	(	const_iterator	hint,
		const value_type &	value
	)

Definition at line 48 of file unordered_map_implementation.h.

◆ insert() [3/10]

template<class Key , class T , class Hash , class Pred , class Alloc >

unordered_map< Key, T, Hash, Pred, Alloc >::iterator atermpp::unordered_map< Key, T, Hash, Pred, Alloc >::insert	(	const_iterator	hint,
		node_type &&	nh
	)

Definition at line 85 of file unordered_map_implementation.h.

◆ insert() [4/10]

template<class Key , class T , class Hash , class Pred , class Alloc >

template<class P >

unordered_map< Key, T, Hash, Pred, Alloc >::iterator atermpp::unordered_map< Key, T, Hash, Pred, Alloc >::insert	(	const_iterator	hint,
		P &&	value
	)

Definition at line 56 of file unordered_map_implementation.h.

◆ insert() [5/10]

template<class Key , class T , class Hash , class Pred , class Alloc >

template<class InputIt >

void atermpp::unordered_map< Key, T, Hash, Pred, Alloc >::insert	(	InputIt	first,
		InputIt	last
	)

Definition at line 64 of file unordered_map_implementation.h.

◆ insert() [6/10]

template<class Key , class T , class Hash , class Pred , class Alloc >

unordered_map< Key, T, Hash, Pred, Alloc >::insert_return_type atermpp::unordered_map< Key, T, Hash, Pred, Alloc >::insert ( node_type && nh )

Definition at line 78 of file unordered_map_implementation.h.

◆ insert() [7/10]

template<class Key , class T , class Hash = std::hash<detail::reference_aterm<Key> >, class Pred = std::equal_to<detail::reference_aterm<Key> >, class Alloc = std::allocator< std::pair<const detail::reference_aterm<Key>, detail::reference_aterm<T> > >>

template<class P >

std::pair< typename unordered_map< Key, T, Hash, Pred, Alloc >::iterator, bool > atermpp::unordered_map< Key, T, Hash, Pred, Alloc >::insert ( P && value )

Definition at line 41 of file unordered_map_implementation.h.

◆ insert() [8/10]

template<class Key , class T , class Hash = std::hash<detail::reference_aterm<Key> >, class Pred = std::equal_to<detail::reference_aterm<Key> >, class Alloc = std::allocator< std::pair<const detail::reference_aterm<Key>, detail::reference_aterm<T> > >>

template<class P >

std::pair< typename unordered_map< Key, T, Hash, Pred, Alloc, ThreadSafe >::iterator, bool > atermpp::unordered_map< Key, T, Hash, Pred, Alloc >::insert ( P && value )

Definition at line 380 of file unordered_map_implementation.h.

◆ insert() [9/10]

template<class Key , class T , class Hash = std::hash<detail::reference_aterm<Key> >, class Pred = std::equal_to<detail::reference_aterm<Key> >, class Alloc = std::allocator< std::pair<const detail::reference_aterm<Key>, detail::reference_aterm<T> > >>

template<class P >

std::pair< iterator, bool > atermpp::unordered_map< Key, T, Hash, Pred, Alloc >::insert ( P && value )

◆ insert() [10/10]

template<class Key , class T , class Hash , class Pred , class Alloc >

void atermpp::unordered_map< Key, T, Hash, Pred, Alloc >::insert ( std::initializer_list< value_type > ilist )

Definition at line 71 of file unordered_map_implementation.h.

◆ insert_or_assign() [1/8]

template<class Key , class T , class Hash = std::hash<detail::reference_aterm<Key> >, class Pred = std::equal_to<detail::reference_aterm<Key> >, class Alloc = std::allocator< std::pair<const detail::reference_aterm<Key>, detail::reference_aterm<T> > >>

template<class M >

std::pair< typename unordered_map< Key, T, Hash, Pred, Alloc >::iterator, bool > atermpp::unordered_map< Key, T, Hash, Pred, Alloc >::insert_or_assign	(	const Key &	k,
		M &&	obj
	)

Definition at line 93 of file unordered_map_implementation.h.

◆ insert_or_assign() [2/8]

template<class Key , class T , class Hash = std::hash<detail::reference_aterm<Key> >, class Pred = std::equal_to<detail::reference_aterm<Key> >, class Alloc = std::allocator< std::pair<const detail::reference_aterm<Key>, detail::reference_aterm<T> > >>

template<class M >

std::pair< typename unordered_map< Key, T, Hash, Pred, Alloc, ThreadSafe >::iterator, bool > atermpp::unordered_map< Key, T, Hash, Pred, Alloc >::insert_or_assign	(	const Key &	k,
		M &&	obj
	)

Definition at line 439 of file unordered_map_implementation.h.

◆ insert_or_assign() [3/8]

template<class Key , class T , class Hash = std::hash<detail::reference_aterm<Key> >, class Pred = std::equal_to<detail::reference_aterm<Key> >, class Alloc = std::allocator< std::pair<const detail::reference_aterm<Key>, detail::reference_aterm<T> > >>

template<class M >

std::pair< iterator, bool > atermpp::unordered_map< Key, T, Hash, Pred, Alloc >::insert_or_assign	(	const Key &	k,
		M &&	obj
	)

◆ insert_or_assign() [4/8]

template<class Key , class T , class Hash , class Pred , class Alloc >

template<class M >

unordered_map< Key, T, Hash, Pred, Alloc >::iterator atermpp::unordered_map< Key, T, Hash, Pred, Alloc >::insert_or_assign	(	const_iterator	hint,
		const Key &	k,
		M &&	obj
	)

Definition at line 109 of file unordered_map_implementation.h.

◆ insert_or_assign() [5/8]

template<class Key , class T , class Hash , class Pred , class Alloc >

template<class M >

unordered_map< Key, T, Hash, Pred, Alloc >::iterator atermpp::unordered_map< Key, T, Hash, Pred, Alloc >::insert_or_assign	(	const_iterator	hint,
		Key &&	k,
		M &&	obj
	)

Definition at line 117 of file unordered_map_implementation.h.

◆ insert_or_assign() [6/8]

template<class Key , class T , class Hash = std::hash<detail::reference_aterm<Key> >, class Pred = std::equal_to<detail::reference_aterm<Key> >, class Alloc = std::allocator< std::pair<const detail::reference_aterm<Key>, detail::reference_aterm<T> > >>

template<class M >

std::pair< typename unordered_map< Key, T, Hash, Pred, Alloc >::iterator, bool > atermpp::unordered_map< Key, T, Hash, Pred, Alloc >::insert_or_assign	(	Key &&	k,
		M &&	obj
	)

Definition at line 101 of file unordered_map_implementation.h.

◆ insert_or_assign() [7/8]

template<class Key , class T , class Hash = std::hash<detail::reference_aterm<Key> >, class Pred = std::equal_to<detail::reference_aterm<Key> >, class Alloc = std::allocator< std::pair<const detail::reference_aterm<Key>, detail::reference_aterm<T> > >>

template<class M >

std::pair< typename unordered_map< Key, T, Hash, Pred, Alloc, ThreadSafe >::iterator, bool > atermpp::unordered_map< Key, T, Hash, Pred, Alloc >::insert_or_assign	(	Key &&	k,
		M &&	obj
	)

Definition at line 448 of file unordered_map_implementation.h.

◆ insert_or_assign() [8/8]

template<class Key , class T , class Hash = std::hash<detail::reference_aterm<Key> >, class Pred = std::equal_to<detail::reference_aterm<Key> >, class Alloc = std::allocator< std::pair<const detail::reference_aterm<Key>, detail::reference_aterm<T> > >>

template<class M >

std::pair< iterator, bool > atermpp::unordered_map< Key, T, Hash, Pred, Alloc >::insert_or_assign	(	Key &&	k,
		M &&	obj
	)

◆ max_size()

template<class Key , class T , class Hash , class Pred , class Alloc >

unordered_map< Key, T, Hash, Pred, Alloc >::size_type atermpp::unordered_map< Key, T, Hash, Pred, Alloc >::max_size

noexcept

Returns: The amount of elements stored in this set.

Definition at line 302 of file unordered_map_implementation.h.

◆ merge() [1/4]

template<class Key , class T , class Hash , class Pred , class Alloc >

template<class H2 , class P2 >

void atermpp::unordered_map< Key, T, Hash, Pred, Alloc >::merge ( std::unordered_map< Key, T, H2, P2, allocator_type > && source )

Definition at line 230 of file unordered_map_implementation.h.

◆ merge() [2/4]

template<class Key , class T , class Hash , class Pred , class Alloc >

template<class H2 , class P2 >

void atermpp::unordered_map< Key, T, Hash, Pred, Alloc >::merge ( std::unordered_map< Key, T, H2, P2, allocator_type > & source )

Definition at line 222 of file unordered_map_implementation.h.

◆ merge() [3/4]

template<class Key , class T , class Hash , class Pred , class Alloc >

template<class H2 , class P2 >

void atermpp::unordered_map< Key, T, Hash, Pred, Alloc >::merge ( std::unordered_multimap< Key, T, H2, P2, allocator_type > && source )

Definition at line 246 of file unordered_map_implementation.h.

◆ merge() [4/4]

template<class Key , class T , class Hash , class Pred , class Alloc >

template<class H2 , class P2 >

void atermpp::unordered_map< Key, T, Hash, Pred, Alloc >::merge ( std::unordered_multimap< Key, T, H2, P2, allocator_type > & source )

Definition at line 238 of file unordered_map_implementation.h.

◆ operator=() [1/2]

template<class Key , class T , class Hash = std::hash<detail::reference_aterm<Key> >, class Pred = std::equal_to<detail::reference_aterm<Key> >, class Alloc = std::allocator< std::pair<const detail::reference_aterm<Key>, detail::reference_aterm<T> > >>

unordered_map & atermpp::unordered_map< Key, T, Hash, Pred, Alloc >::operator= ( const unordered_map< Key, T, Hash, Pred, Alloc > & other )

default

Standard assignment.

◆ operator=() [2/2]

template<class Key , class T , class Hash = std::hash<detail::reference_aterm<Key> >, class Pred = std::equal_to<detail::reference_aterm<Key> >, class Alloc = std::allocator< std::pair<const detail::reference_aterm<Key>, detail::reference_aterm<T> > >>

unordered_map & atermpp::unordered_map< Key, T, Hash, Pred, Alloc >::operator= ( unordered_map< Key, T, Hash, Pred, Alloc > && other )

default

Standard move assignment.

◆ size()

template<class Key , class T , class Hash = std::hash<detail::reference_aterm<Key> >, class Pred = std::equal_to<detail::reference_aterm<Key> >, class Alloc = std::allocator< std::pair<const detail::reference_aterm<Key>, detail::reference_aterm<T> > >>

std::size_t atermpp::unordered_map< Key, T, Hash, Pred, Alloc >::size ( ) const

inline

Definition at line 204 of file unordered_map.h.

◆ swap()

template<class Key , class T , class Hash , class Pred , class Alloc >

void atermpp::unordered_map< Key, T, Hash, Pred, Alloc >::swap ( unordered_map< Key, T, Hash, Pred, Alloc > & other )

Definition at line 200 of file unordered_map_implementation.h.

◆ try_emplace() [1/8]

template<class Key , class T , class Hash = std::hash<detail::reference_aterm<Key> >, class Pred = std::equal_to<detail::reference_aterm<Key> >, class Alloc = std::allocator< std::pair<const detail::reference_aterm<Key>, detail::reference_aterm<T> > >>

template<class... Args>

std::pair< typename unordered_map< Key, T, Hash, Pred, Alloc >::iterator, bool > atermpp::unordered_map< Key, T, Hash, Pred, Alloc >::try_emplace	(	const Key &	k,
		Args &&...	args
	)

Definition at line 141 of file unordered_map_implementation.h.

◆ try_emplace() [2/8]

template<class Key , class T , class Hash = std::hash<detail::reference_aterm<Key> >, class Pred = std::equal_to<detail::reference_aterm<Key> >, class Alloc = std::allocator< std::pair<const detail::reference_aterm<Key>, detail::reference_aterm<T> > >>

template<class... Args>

std::pair< typename unordered_map< Key, T, Hash, Pred, Alloc, ThreadSafe >::iterator, bool > atermpp::unordered_map< Key, T, Hash, Pred, Alloc >::try_emplace	(	const Key &	k,
		Args &&...	args
	)

Definition at line 493 of file unordered_map_implementation.h.

◆ try_emplace() [3/8]

template<class Key , class T , class Hash = std::hash<detail::reference_aterm<Key> >, class Pred = std::equal_to<detail::reference_aterm<Key> >, class Alloc = std::allocator< std::pair<const detail::reference_aterm<Key>, detail::reference_aterm<T> > >>

template<class... Args>

std::pair< iterator, bool > atermpp::unordered_map< Key, T, Hash, Pred, Alloc >::try_emplace	(	const Key &	k,
		Args &&...	args
	)

◆ try_emplace() [4/8]

template<class Key , class T , class Hash , class Pred , class Alloc >

template<class... Args>

unordered_map< Key, T, Hash, Pred, Alloc >::iterator atermpp::unordered_map< Key, T, Hash, Pred, Alloc >::try_emplace	(	const_iterator	hint,
		const Key &	k,
		Args &&...	args
	)

Definition at line 157 of file unordered_map_implementation.h.

◆ try_emplace() [5/8]

template<class Key , class T , class Hash , class Pred , class Alloc >

template<class... Args>

unordered_map< Key, T, Hash, Pred, Alloc >::iterator atermpp::unordered_map< Key, T, Hash, Pred, Alloc >::try_emplace	(	const_iterator	hint,
		Key &&	k,
		Args &&...	args
	)

Definition at line 165 of file unordered_map_implementation.h.

◆ try_emplace() [6/8]

template<class Key , class T , class Hash = std::hash<detail::reference_aterm<Key> >, class Pred = std::equal_to<detail::reference_aterm<Key> >, class Alloc = std::allocator< std::pair<const detail::reference_aterm<Key>, detail::reference_aterm<T> > >>

template<class... Args>

std::pair< typename unordered_map< Key, T, Hash, Pred, Alloc >::iterator, bool > atermpp::unordered_map< Key, T, Hash, Pred, Alloc >::try_emplace	(	Key &&	k,
		Args &&...	args
	)

Definition at line 149 of file unordered_map_implementation.h.

◆ try_emplace() [7/8]

template<class Key , class T , class Hash = std::hash<detail::reference_aterm<Key> >, class Pred = std::equal_to<detail::reference_aterm<Key> >, class Alloc = std::allocator< std::pair<const detail::reference_aterm<Key>, detail::reference_aterm<T> > >>

template<class... Args>

std::pair< typename unordered_map< Key, T, Hash, Pred, Alloc, ThreadSafe >::iterator, bool > atermpp::unordered_map< Key, T, Hash, Pred, Alloc >::try_emplace	(	Key &&	k,
		Args &&...	args
	)

Definition at line 502 of file unordered_map_implementation.h.

◆ try_emplace() [8/8]

template<class Key , class T , class Hash = std::hash<detail::reference_aterm<Key> >, class Pred = std::equal_to<detail::reference_aterm<Key> >, class Alloc = std::allocator< std::pair<const detail::reference_aterm<Key>, detail::reference_aterm<T> > >>

template<class... Args>

std::pair< iterator, bool > atermpp::unordered_map< Key, T, Hash, Pred, Alloc >::try_emplace	(	Key &&	k,
		Args &&...	args
	)

Member Data Documentation

◆ container_wrapper

template<class Key , class T , class Hash = std::hash<detail::reference_aterm<Key> >, class Pred = std::equal_to<detail::reference_aterm<Key> >, class Alloc = std::allocator< std::pair<const detail::reference_aterm<Key>, detail::reference_aterm<T> > >>

detail::generic_aterm_container<std::unordered_map< detail::reference_aterm<Key>, detail::reference_aterm<T>, Hash, Pred, Alloc > > atermpp::unordered_map< Key, T, Hash, Pred, Alloc >::container_wrapper

protected

Definition at line 42 of file unordered_map.h.

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

atermpp/include/mcrl2/atermpp/standard_containers/unordered_map.h
atermpp/include/mcrl2/atermpp/standard_containers/detail/unordered_map_implementation.h

Public Types

Public Member Functions

Protected Types

Protected Attributes

Detailed Description

Member Typedef Documentation

◆ allocator_type

◆ const_iterator

◆ insert_return_type

◆ iterator

◆ node_type

◆ reference

◆ size_type

◆ super

◆ value_type

Constructor & Destructor Documentation

◆ unordered_map() [1/10]

◆ unordered_map() [2/10]

◆ unordered_map() [3/10]

◆ unordered_map() [4/10]

◆ unordered_map() [5/10]

◆ unordered_map() [6/10]

◆ unordered_map() [7/10]

◆ unordered_map() [8/10]

◆ unordered_map() [9/10]

◆ unordered_map() [10/10]

◆ ~unordered_map()

Member Function Documentation

◆ begin() [1/2]

◆ begin() [2/2]

◆ cbegin()

◆ cend()

◆ clear()

◆ emplace() [1/3]

◆ emplace() [2/3]

◆ emplace() [3/3]

◆ emplace_hint()

◆ empty()

◆ end() [1/2]

◆ end() [2/2]

◆ erase() [1/4]

◆ erase() [2/4]

◆ erase() [3/4]

◆ erase() [4/4]

◆ extract() [1/2]

◆ extract() [2/2]

◆ insert() [1/10]

◆ insert() [2/10]

◆ insert() [3/10]

◆ insert() [4/10]

◆ insert() [5/10]

◆ insert() [6/10]

◆ insert() [7/10]

◆ insert() [8/10]

◆ insert() [9/10]

◆ insert() [10/10]

◆ insert_or_assign() [1/8]

◆ insert_or_assign() [2/8]

◆ insert_or_assign() [3/8]

◆ insert_or_assign() [4/8]

◆ insert_or_assign() [5/8]

◆ insert_or_assign() [6/8]

◆ insert_or_assign() [7/8]

◆ insert_or_assign() [8/8]

◆ max_size()

◆ merge() [1/4]

◆ merge() [2/4]

◆ merge() [3/4]

◆ merge() [4/4]

◆ operator=() [1/2]

◆ operator=() [2/2]

◆ size()

◆ swap()

◆ try_emplace() [1/8]

◆ try_emplace() [2/8]

◆ try_emplace() [3/8]

◆ try_emplace() [4/8]

◆ try_emplace() [5/8]

◆ try_emplace() [6/8]

◆ try_emplace() [7/8]