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

#include <unordered_map.h>

Public Types
using	key_type = typename super::key_type
	Standard typedefs.

using	mapped_type = typename super::mapped_type

using	allocator_type = typename super::allocator_type

using	value_type = typename super::value_type

using	size_type = typename super::size_type

using	node_type = typename super::node_type

using	reference = typename super::reference

using	const_reference = typename super::const_reference

using	iterator = typename super::iterator

using	const_iterator = typename super::const_iterator

using	insert_return_type = typename super::insert_return_type

using	hasher = typename super::hasher

using	key_equal = typename super::key_equal

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.

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) noexcept
	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.

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

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

	~unordered_map ()=default
	Standard destructor.

allocator_type	get_allocator () const noexcept

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 > requires std::constructible_from<typename std::unordered_map<detail::markable_aterm<Key>, detail::markable_aterm<T>, Hash, Pred, Alloc>::value_type, P>
std::pair< iterator, bool >	insert (P &&value)

iterator	insert (const_iterator hint, const value_type &value)

template<class P > requires std::constructible_from<typename std::unordered_map<detail::markable_aterm<Key>, detail::markable_aterm<T>, Hash, Pred, Alloc>::value_type, 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) noexcept

node_type	extract (const_iterator position)

node_type	extract (const Key &k)

mapped_type &	operator[] (const Key &key)
	Provides access to the value associated with the given key, inserting a default value when the key is not yet present.

mapped_type &	at (const Key &key)
	Provides access to the value associated with the given key.

const mapped_type &	at (const Key &key) const

iterator	find (const Key &key)

const_iterator	find (const Key &key) const

size_type	count (const Key &key) const

bool	contains (const Key &key) const

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

void	rehash (size_type count)

void	reserve (size_type count)

hasher	hash_function () const

key_equal	key_eq () const

void	mark (term_mark_stack &todo) const
	Marks all stored terms during garbage collection; used when this container is an element of another protected container.

bool	operator== (const unordered_map &other) const

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

template<class P > requires std::constructible_from<typename std::unordered_map<detail::markable_aterm<Key>, detail::markable_aterm<T>, Hash, Pred, Alloc>::value_type, P>
unordered_map< Key, T, Hash, Pred, Alloc >::iterator	insert (const_iterator hint, P &&value)

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

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

Protected Types
using	super = std::unordered_map< detail::markable_aterm< Key >, detail::markable_aterm< T >, Hash, Pred, Alloc >

Protected Attributes
super	m_container

detail::generic_aterm_container< super >	container_wrapper

Detailed Description

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

A unordered_map class in which aterms can be stored.

The API of a std::unordered_map is exposed by explicit forwarding (composition) instead of inheritance, such that every operation is guaranteed to acquire the shared lock that keeps the garbage collector out of the container while it is used.

Definition at line 41 of file unordered_map.h.

Member Typedef Documentation

◆ allocator_type

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

using atermpp::unordered_map< Key, T, Hash, Pred, Alloc >::allocator_type = typename super::allocator_type

Definition at line 54 of file unordered_map.h.

◆ const_iterator

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

using atermpp::unordered_map< Key, T, Hash, Pred, Alloc >::const_iterator = typename super::const_iterator

Definition at line 61 of file unordered_map.h.

◆ const_reference

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

using atermpp::unordered_map< Key, T, Hash, Pred, Alloc >::const_reference = typename super::const_reference

Definition at line 59 of file unordered_map.h.

◆ hasher

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

using atermpp::unordered_map< Key, T, Hash, Pred, Alloc >::hasher = typename super::hasher

Definition at line 63 of file unordered_map.h.

◆ insert_return_type

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

using atermpp::unordered_map< Key, T, Hash, Pred, Alloc >::insert_return_type = typename super::insert_return_type

Definition at line 62 of file unordered_map.h.

◆ iterator

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

using atermpp::unordered_map< Key, T, Hash, Pred, Alloc >::iterator = typename super::iterator

Definition at line 60 of file unordered_map.h.

◆ key_equal

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

using atermpp::unordered_map< Key, T, Hash, Pred, Alloc >::key_equal = typename super::key_equal

Definition at line 64 of file unordered_map.h.

◆ key_type

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

using atermpp::unordered_map< Key, T, Hash, Pred, Alloc >::key_type = typename super::key_type

Standard typedefs.

Definition at line 52 of file unordered_map.h.

◆ mapped_type

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

using atermpp::unordered_map< Key, T, Hash, Pred, Alloc >::mapped_type = typename super::mapped_type

Definition at line 53 of file unordered_map.h.

◆ node_type

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

using atermpp::unordered_map< Key, T, Hash, Pred, Alloc >::node_type = typename super::node_type

Definition at line 57 of file unordered_map.h.

◆ reference

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

using atermpp::unordered_map< Key, T, Hash, Pred, Alloc >::reference = typename super::reference

Definition at line 58 of file unordered_map.h.

◆ size_type

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

using atermpp::unordered_map< Key, T, Hash, Pred, Alloc >::size_type = typename super::size_type

Definition at line 56 of file unordered_map.h.

◆ super

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

using atermpp::unordered_map< Key, T, Hash, Pred, Alloc >::super = std::unordered_map<detail::markable_aterm<Key>, detail::markable_aterm<T>, Hash, Pred, Alloc>

protected

Definition at line 44 of file unordered_map.h.

◆ value_type

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

using atermpp::unordered_map< Key, T, Hash, Pred, Alloc >::value_type = typename super::value_type

Definition at line 55 of file unordered_map.h.

Constructor & Destructor Documentation

◆ unordered_map() [1/9]

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

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

inline

Default constructor.

Definition at line 67 of file unordered_map.h.

◆ unordered_map() [2/9]

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

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

inlineexplicit

Constructor.

Definition at line 73 of file unordered_map.h.

◆ unordered_map() [3/9]

template<class Key , class T , class Hash = std::hash<detail::markable_aterm<Key> >, class Pred = std::equal_to<detail::markable_aterm<Key> >, class Alloc = std::allocator< std::pair<const detail::markable_aterm<Key>, detail::markable_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 79 of file unordered_map.h.

◆ unordered_map() [4/9]

template<class Key , class T , class Hash = std::hash<detail::markable_aterm<Key> >, class Pred = std::equal_to<detail::markable_aterm<Key> >, class Alloc = std::allocator< std::pair<const detail::markable_aterm<Key>, detail::markable_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 86 of file unordered_map.h.

◆ unordered_map() [5/9]

template<class Key , class T , class Hash = std::hash<detail::markable_aterm<Key> >, class Pred = std::equal_to<detail::markable_aterm<Key> >, class Alloc = std::allocator< std::pair<const detail::markable_aterm<Key>, detail::markable_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 92 of file unordered_map.h.

◆ unordered_map() [6/9]

template<class Key , class T , class Hash = std::hash<detail::markable_aterm<Key> >, class Pred = std::equal_to<detail::markable_aterm<Key> >, class Alloc = std::allocator< std::pair<const detail::markable_aterm<Key>, detail::markable_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 98 of file unordered_map.h.

◆ unordered_map() [7/9]

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

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

inlinenoexcept

Constructor.

Definition at line 104 of file unordered_map.h.

◆ unordered_map() [8/9]

template<class Key , class T , class Hash = std::hash<detail::markable_aterm<Key> >, class Pred = std::equal_to<detail::markable_aterm<Key> >, class Alloc = std::allocator< std::pair<const detail::markable_aterm<Key>, detail::markable_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 111 of file unordered_map.h.

◆ unordered_map() [9/9]

template<class Key , class T , class Hash = std::hash<detail::markable_aterm<Key> >, class Pred = std::equal_to<detail::markable_aterm<Key> >, class Alloc = std::allocator< std::pair<const detail::markable_aterm<Key>, detail::markable_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.

Definition at line 117 of file unordered_map.h.

◆ ~unordered_map()

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

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

default

Standard destructor.

Member Function Documentation

◆ at() [1/2]

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

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

Provides access to the value associated with the given key.

Definition at line 253 of file unordered_map_implementation.h.

◆ at() [2/2]

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

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

◆ begin() [1/2]

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

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

inline

Returns: An iterator over all keys.

◆ begin() [2/2]

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

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

Returns: A const iterator over all keys.

◆ cbegin()

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

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

Returns: A const iterator over all keys.

◆ cend()

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

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

◆ clear()

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

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

noexcept

◆ contains()

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

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

Returns: Whether an element with the specified key is stored.

Definition at line 288 of file unordered_map_implementation.h.

◆ count()

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

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

Returns: The number of elements matching the specified key.

◆ emplace()

template<class Key , class T , class Hash = std::hash<detail::markable_aterm<Key> >, class Pred = std::equal_to<detail::markable_aterm<Key> >, class Alloc = std::allocator< std::pair<const detail::markable_aterm<Key>, detail::markable_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 = std::hash<detail::markable_aterm<Key> >, class Pred = std::equal_to<detail::markable_aterm<Key> >, class Alloc = std::allocator< std::pair<const detail::markable_aterm<Key>, detail::markable_aterm<T> > >>

template<class... Args>

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

◆ empty()

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

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

noexcept

Returns: True iff the set is empty.

◆ end() [1/2]

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

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

inline

◆ end() [2/2]

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

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

◆ erase() [1/4]

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

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

◆ erase() [2/4]

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

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

◆ erase() [3/4]

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

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

◆ erase() [4/4]

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

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

◆ extract() [1/2]

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

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

Definition at line 238 of file unordered_map_implementation.h.

◆ extract() [2/2]

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

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

Definition at line 231 of file unordered_map_implementation.h.

◆ find() [1/2]

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

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

Returns: Element with the specified key, or end() otherwise.

Definition at line 267 of file unordered_map_implementation.h.

◆ find() [2/2]

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

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

Definition at line 274 of file unordered_map_implementation.h.

◆ get_allocator()

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

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

inlinenoexcept

Returns: The allocator of the underlying container.

Definition at line 132 of file unordered_map.h.

◆ hash_function()

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

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

inline

Definition at line 255 of file unordered_map.h.

◆ insert() [1/12]

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

std::pair< 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.

◆ insert() [2/12]

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

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

◆ insert() [3/12]

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

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 109 of file unordered_map_implementation.h.

◆ insert() [4/12]

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

template<class P >
requires std::constructible_from<typename std::unordered_map<detail::markable_aterm<Key>, detail::markable_aterm<T>, Hash, Pred, Alloc>::value_type, 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 80 of file unordered_map_implementation.h.

◆ insert() [5/12]

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

template<class P >
requires std::constructible_from<typename std::unordered_map<detail::markable_aterm<Key>, detail::markable_aterm<T>, Hash, Pred, Alloc>::value_type, P>

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

◆ insert() [6/12]

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

template<class InputIt >

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

Definition at line 88 of file unordered_map_implementation.h.

◆ insert() [7/12]

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

template<class InputIt >

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

◆ insert() [8/12]

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

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 102 of file unordered_map_implementation.h.

◆ insert() [9/12]

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

template<class P >
requires std::constructible_from<typename std::unordered_map<detail::markable_aterm<Key>, detail::markable_aterm<T>, Hash, Pred, Alloc>::value_type, 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 64 of file unordered_map_implementation.h.

◆ insert() [10/12]

template<class Key , class T , class Hash = std::hash<detail::markable_aterm<Key> >, class Pred = std::equal_to<detail::markable_aterm<Key> >, class Alloc = std::allocator< std::pair<const detail::markable_aterm<Key>, detail::markable_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 505 of file unordered_map_implementation.h.

◆ insert() [11/12]

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

template<class P >
requires std::constructible_from<typename std::unordered_map<detail::markable_aterm<Key>, detail::markable_aterm<T>, Hash, Pred, Alloc>::value_type, P>

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

◆ insert() [12/12]

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

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

◆ insert_or_assign() [1/4]

template<class Key , class T , class Hash = std::hash<detail::markable_aterm<Key> >, class Pred = std::equal_to<detail::markable_aterm<Key> >, class Alloc = std::allocator< std::pair<const detail::markable_aterm<Key>, detail::markable_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() [2/4]

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

template<class M >

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

◆ insert_or_assign() [3/4]

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

template<class M >

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

◆ insert_or_assign() [4/4]

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

template<class M >

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

◆ key_eq()

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

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

inline

Definition at line 256 of file unordered_map.h.

◆ mark()

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

void atermpp::unordered_map< Key, T, Hash, Pred, Alloc >::mark ( term_mark_stack & todo ) const

inline

Marks all stored terms during garbage collection; used when this container is an element of another protected container.

Definition at line 260 of file unordered_map.h.

◆ max_size()

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

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

noexcept

Returns: The amount of elements stored in this set.

◆ operator=() [1/2]

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

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

Standard assignment.

◆ operator=() [2/2]

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

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

noexcept

Standard move assignment.

◆ operator==()

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

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

inline

Definition at line 269 of file unordered_map.h.

◆ operator[]()

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

mapped_type & atermpp::unordered_map< Key, T, Hash, Pred, Alloc >::operator[] ( const Key & key )

Provides access to the value associated with the given key, inserting a default value when the key is not yet present.

◆ rehash()

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

void atermpp::unordered_map< Key, T, Hash, Pred, Alloc >::rehash ( size_type count )

◆ reserve()

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

void atermpp::unordered_map< Key, T, Hash, Pred, Alloc >::reserve ( size_type count )

◆ size()

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

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

inline

Definition at line 223 of file unordered_map.h.

◆ swap()

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

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

noexcept

◆ try_emplace() [1/4]

template<class Key , class T , class Hash = std::hash<detail::markable_aterm<Key> >, class Pred = std::equal_to<detail::markable_aterm<Key> >, class Alloc = std::allocator< std::pair<const detail::markable_aterm<Key>, detail::markable_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() [2/4]

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

template<class... Args>

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

◆ try_emplace() [3/4]

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

template<class... Args>

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

◆ try_emplace() [4/4]

template<class Key , class T , class Hash = std::hash<detail::markable_aterm<Key> >, class Pred = std::equal_to<detail::markable_aterm<Key> >, class Alloc = std::allocator< std::pair<const detail::markable_aterm<Key>, detail::markable_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::markable_aterm<Key> >, class Pred = std::equal_to<detail::markable_aterm<Key> >, class Alloc = std::allocator< std::pair<const detail::markable_aterm<Key>, detail::markable_aterm<T> > >>

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

protected

Definition at line 47 of file unordered_map.h.

◆ m_container

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

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

protected

Definition at line 46 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

◆ const_reference

◆ hasher

◆ insert_return_type

◆ iterator

◆ key_equal

◆ key_type

◆ mapped_type

◆ node_type

◆ reference

◆ size_type

◆ super

◆ value_type

Constructor & Destructor Documentation

◆ unordered_map() [1/9]

◆ unordered_map() [2/9]

◆ unordered_map() [3/9]

◆ unordered_map() [4/9]

◆ unordered_map() [5/9]

◆ unordered_map() [6/9]

◆ unordered_map() [7/9]

◆ unordered_map() [8/9]

◆ unordered_map() [9/9]

◆ ~unordered_map()

Member Function Documentation

◆ at() [1/2]

◆ at() [2/2]

◆ begin() [1/2]

◆ begin() [2/2]

◆ cbegin()

◆ cend()

◆ clear()

◆ contains()

◆ count()

◆ emplace()

◆ 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]

◆ find() [1/2]

◆ find() [2/2]

◆ get_allocator()

◆ hash_function()

◆ insert() [1/12]

◆ insert() [2/12]

◆ insert() [3/12]

◆ insert() [4/12]

◆ insert() [5/12]

◆ insert() [6/12]

◆ insert() [7/12]

◆ insert() [8/12]

◆ insert() [9/12]

◆ insert() [10/12]

◆ insert() [11/12]

◆ insert() [12/12]

◆ insert_or_assign() [1/4]

◆ insert_or_assign() [2/4]

◆ insert_or_assign() [3/4]

◆ insert_or_assign() [4/4]

◆ key_eq()

◆ mark()

◆ max_size()

◆ operator=() [1/2]

◆ operator=() [2/2]

◆ operator==()

◆ operator[]()

◆ rehash()