LIEF: Library to Instrument Executable Formats: frozen::unordered_map< Key, Value, N, Hash, KeyEqual > Class Template Reference

LIEF: Library to Instrument Executable Formats Version 1.0.0

Loading...

Searching...

No Matches

#include <unordered_map.h>

Inheritance diagram for frozen::unordered_map< Key, Value, N, Hash, KeyEqual >:

Inheritance graph

[legend]

Collaboration diagram for frozen::unordered_map< Key, Value, N, Hash, KeyEqual >:

Collaboration graph

[legend]

Public Types
using	Self = unordered_map<Key, Value, N, Hash, KeyEqual>
using	key_type = Key
using	mapped_type = Value
using	value_type = typename container_type::value_type
using	size_type = typename container_type::size_type
using	difference_type = typename container_type::difference_type
using	hasher = Hash
using	key_equal = KeyEqual
using	reference = typename container_type::reference
using	const_reference = typename container_type::const_reference
using	pointer = typename container_type::pointer
using	const_pointer = typename container_type::const_pointer
using	iterator = typename container_type::iterator
using	const_iterator = typename container_type::const_iterator

Public Member Functions
	unordered_map (unordered_map const &)=default
constexpr	unordered_map (container_type items, Hash const &hash, KeyEqual const &equal)
constexpr	unordered_map (container_type items)
constexpr	unordered_map (std::initializer_list< value_type > items, Hash const &hash, KeyEqual const &equal)
constexpr	unordered_map (std::initializer_list< value_type > items)
constexpr iterator	begin ()
constexpr iterator	end ()
constexpr const_iterator	begin () const
constexpr const_iterator	end () const
constexpr const_iterator	cbegin () const
constexpr const_iterator	cend () const
constexpr bool	empty () const
constexpr size_type	size () const
constexpr size_type	max_size () const
template<class KeyType>
constexpr std::size_t	count (KeyType const &key) const
template<class KeyType>
constexpr Value const &	at (KeyType const &key) const
template<class KeyType>
constexpr Value &	at (KeyType const &key)
template<class KeyType>
constexpr const_iterator	find (KeyType const &key) const
template<class KeyType>
constexpr iterator	find (KeyType const &key)
template<class KeyType>
constexpr bool	contains (KeyType const &key) const
template<class KeyType>
constexpr std::pair< const_iterator, const_iterator >	equal_range (KeyType const &key) const
template<class KeyType>
constexpr std::pair< iterator, iterator >	equal_range (KeyType const &key)
constexpr std::size_t	bucket_count () const
constexpr std::size_t	max_bucket_count () const
constexpr const hasher &	hash_function () const
constexpr const key_equal &	key_eq () const

Member Typedef Documentation

◆ const_iterator

template<class Key, class Value, std::size_t N, typename Hash = anna<Key>, class KeyEqual = std::equal_to<Key>>

using frozen::unordered_map< Key, Value, N, Hash, KeyEqual >::const_iterator = typename container_type::const_iterator

◆ const_pointer

template<class Key, class Value, std::size_t N, typename Hash = anna<Key>, class KeyEqual = std::equal_to<Key>>

using frozen::unordered_map< Key, Value, N, Hash, KeyEqual >::const_pointer = typename container_type::const_pointer

◆ const_reference

template<class Key, class Value, std::size_t N, typename Hash = anna<Key>, class KeyEqual = std::equal_to<Key>>

using frozen::unordered_map< Key, Value, N, Hash, KeyEqual >::const_reference = typename container_type::const_reference

◆ difference_type

template<class Key, class Value, std::size_t N, typename Hash = anna<Key>, class KeyEqual = std::equal_to<Key>>

using frozen::unordered_map< Key, Value, N, Hash, KeyEqual >::difference_type = typename container_type::difference_type

◆ hasher

template<class Key, class Value, std::size_t N, typename Hash = anna<Key>, class KeyEqual = std::equal_to<Key>>

using frozen::unordered_map< Key, Value, N, Hash, KeyEqual >::hasher = Hash

◆ iterator

template<class Key, class Value, std::size_t N, typename Hash = anna<Key>, class KeyEqual = std::equal_to<Key>>

using frozen::unordered_map< Key, Value, N, Hash, KeyEqual >::iterator = typename container_type::iterator

◆ key_equal

template<class Key, class Value, std::size_t N, typename Hash = anna<Key>, class KeyEqual = std::equal_to<Key>>

using frozen::unordered_map< Key, Value, N, Hash, KeyEqual >::key_equal = KeyEqual

◆ key_type

template<class Key, class Value, std::size_t N, typename Hash = anna<Key>, class KeyEqual = std::equal_to<Key>>

using frozen::unordered_map< Key, Value, N, Hash, KeyEqual >::key_type = Key

◆ mapped_type

template<class Key, class Value, std::size_t N, typename Hash = anna<Key>, class KeyEqual = std::equal_to<Key>>

using frozen::unordered_map< Key, Value, N, Hash, KeyEqual >::mapped_type = Value

◆ pointer

template<class Key, class Value, std::size_t N, typename Hash = anna<Key>, class KeyEqual = std::equal_to<Key>>

using frozen::unordered_map< Key, Value, N, Hash, KeyEqual >::pointer = typename container_type::pointer

◆ reference

template<class Key, class Value, std::size_t N, typename Hash = anna<Key>, class KeyEqual = std::equal_to<Key>>

using frozen::unordered_map< Key, Value, N, Hash, KeyEqual >::reference = typename container_type::reference

◆ Self

template<class Key, class Value, std::size_t N, typename Hash = anna<Key>, class KeyEqual = std::equal_to<Key>>

using frozen::unordered_map< Key, Value, N, Hash, KeyEqual >::Self = unordered_map<Key, Value, N, Hash, KeyEqual>

◆ size_type

template<class Key, class Value, std::size_t N, typename Hash = anna<Key>, class KeyEqual = std::equal_to<Key>>

using frozen::unordered_map< Key, Value, N, Hash, KeyEqual >::size_type = typename container_type::size_type

◆ value_type

template<class Key, class Value, std::size_t N, typename Hash = anna<Key>, class KeyEqual = std::equal_to<Key>>

using frozen::unordered_map< Key, Value, N, Hash, KeyEqual >::value_type = typename container_type::value_type

Constructor & Destructor Documentation

◆ unordered_map() [1/5]

template<class Key, class Value, std::size_t N, typename Hash = anna<Key>, class KeyEqual = std::equal_to<Key>>

frozen::unordered_map< Key, Value, N, Hash, KeyEqual >::unordered_map ( unordered_map< Key, Value, N, Hash, KeyEqual > const & )

default

◆ unordered_map() [2/5]

template<class Key, class Value, std::size_t N, typename Hash = anna<Key>, class KeyEqual = std::equal_to<Key>>

frozen::unordered_map< Key, Value, N, Hash, KeyEqual >::unordered_map	(	container_type	items,
		Hash const &	hash,
		KeyEqual const &	equal )

inlineconstexpr

◆ unordered_map() [3/5]

template<class Key, class Value, std::size_t N, typename Hash = anna<Key>, class KeyEqual = std::equal_to<Key>>

frozen::unordered_map< Key, Value, N, Hash, KeyEqual >::unordered_map ( container_type items )

inlineexplicitconstexpr

◆ unordered_map() [4/5]

template<class Key, class Value, std::size_t N, typename Hash = anna<Key>, class KeyEqual = std::equal_to<Key>>

frozen::unordered_map< Key, Value, N, Hash, KeyEqual >::unordered_map	(	std::initializer_list< value_type >	items,
		Hash const &	hash,
		KeyEqual const &	equal )

inlineconstexpr

◆ unordered_map() [5/5]

template<class Key, class Value, std::size_t N, typename Hash = anna<Key>, class KeyEqual = std::equal_to<Key>>

frozen::unordered_map< Key, Value, N, Hash, KeyEqual >::unordered_map ( std::initializer_list< value_type > items )

inlineconstexpr

Member Function Documentation

◆ at() [1/2]

template<class Key, class Value, std::size_t N, typename Hash = anna<Key>, class KeyEqual = std::equal_to<Key>>

template<class KeyType>

Value & frozen::unordered_map< Key, Value, N, Hash, KeyEqual >::at ( KeyType const & key )

inlineconstexpr

◆ at() [2/2]

template<class Key, class Value, std::size_t N, typename Hash = anna<Key>, class KeyEqual = std::equal_to<Key>>

template<class KeyType>

Value const & frozen::unordered_map< Key, Value, N, Hash, KeyEqual >::at ( KeyType const & key ) const

inlineconstexpr

◆ begin() [1/2]

template<class Key, class Value, std::size_t N, typename Hash = anna<Key>, class KeyEqual = std::equal_to<Key>>

iterator frozen::unordered_map< Key, Value, N, Hash, KeyEqual >::begin ( )

inlineconstexpr

◆ begin() [2/2]

template<class Key, class Value, std::size_t N, typename Hash = anna<Key>, class KeyEqual = std::equal_to<Key>>

const_iterator frozen::unordered_map< Key, Value, N, Hash, KeyEqual >::begin ( ) const

inlineconstexpr

◆ bucket_count()

template<class Key, class Value, std::size_t N, typename Hash = anna<Key>, class KeyEqual = std::equal_to<Key>>

std::size_t frozen::unordered_map< Key, Value, N, Hash, KeyEqual >::bucket_count ( ) const

inlineconstexpr

◆ cbegin()

template<class Key, class Value, std::size_t N, typename Hash = anna<Key>, class KeyEqual = std::equal_to<Key>>

const_iterator frozen::unordered_map< Key, Value, N, Hash, KeyEqual >::cbegin ( ) const

inlineconstexpr

◆ cend()

template<class Key, class Value, std::size_t N, typename Hash = anna<Key>, class KeyEqual = std::equal_to<Key>>

const_iterator frozen::unordered_map< Key, Value, N, Hash, KeyEqual >::cend ( ) const

inlineconstexpr

◆ contains()

template<class Key, class Value, std::size_t N, typename Hash = anna<Key>, class KeyEqual = std::equal_to<Key>>

template<class KeyType>

bool frozen::unordered_map< Key, Value, N, Hash, KeyEqual >::contains ( KeyType const & key ) const

inlineconstexpr

◆ count()

template<class Key, class Value, std::size_t N, typename Hash = anna<Key>, class KeyEqual = std::equal_to<Key>>

template<class KeyType>

std::size_t frozen::unordered_map< Key, Value, N, Hash, KeyEqual >::count ( KeyType const & key ) const

inlineconstexpr

◆ empty()

template<class Key, class Value, std::size_t N, typename Hash = anna<Key>, class KeyEqual = std::equal_to<Key>>

bool frozen::unordered_map< Key, Value, N, Hash, KeyEqual >::empty ( ) const

inlineconstexpr

◆ end() [1/2]

template<class Key, class Value, std::size_t N, typename Hash = anna<Key>, class KeyEqual = std::equal_to<Key>>

iterator frozen::unordered_map< Key, Value, N, Hash, KeyEqual >::end ( )

inlineconstexpr

Referenced by contains(), and count().

◆ end() [2/2]

template<class Key, class Value, std::size_t N, typename Hash = anna<Key>, class KeyEqual = std::equal_to<Key>>

const_iterator frozen::unordered_map< Key, Value, N, Hash, KeyEqual >::end ( ) const

inlineconstexpr

◆ equal_range() [1/2]

template<class Key, class Value, std::size_t N, typename Hash = anna<Key>, class KeyEqual = std::equal_to<Key>>

template<class KeyType>

std::pair< iterator, iterator > frozen::unordered_map< Key, Value, N, Hash, KeyEqual >::equal_range ( KeyType const & key )

inlineconstexpr

◆ equal_range() [2/2]

template<class Key, class Value, std::size_t N, typename Hash = anna<Key>, class KeyEqual = std::equal_to<Key>>

template<class KeyType>

std::pair< const_iterator, const_iterator > frozen::unordered_map< Key, Value, N, Hash, KeyEqual >::equal_range ( KeyType const & key ) const

inlineconstexpr

◆ find() [1/2]

template<class Key, class Value, std::size_t N, typename Hash = anna<Key>, class KeyEqual = std::equal_to<Key>>

template<class KeyType>

iterator frozen::unordered_map< Key, Value, N, Hash, KeyEqual >::find ( KeyType const & key )

inlineconstexpr

◆ find() [2/2]

template<class Key, class Value, std::size_t N, typename Hash = anna<Key>, class KeyEqual = std::equal_to<Key>>

template<class KeyType>

const_iterator frozen::unordered_map< Key, Value, N, Hash, KeyEqual >::find ( KeyType const & key ) const

inlineconstexpr

Referenced by contains(), and count().

◆ hash_function()

template<class Key, class Value, std::size_t N, typename Hash = anna<Key>, class KeyEqual = std::equal_to<Key>>

const hasher & frozen::unordered_map< Key, Value, N, Hash, KeyEqual >::hash_function ( ) const

inlineconstexpr

Referenced by find(), and find().

◆ key_eq()

template<class Key, class Value, std::size_t N, typename Hash = anna<Key>, class KeyEqual = std::equal_to<Key>>

const key_equal & frozen::unordered_map< Key, Value, N, Hash, KeyEqual >::key_eq ( ) const

inlineconstexpr

Referenced by find(), and find().

◆ max_bucket_count()

template<class Key, class Value, std::size_t N, typename Hash = anna<Key>, class KeyEqual = std::equal_to<Key>>

std::size_t frozen::unordered_map< Key, Value, N, Hash, KeyEqual >::max_bucket_count ( ) const

inlineconstexpr

◆ max_size()

template<class Key, class Value, std::size_t N, typename Hash = anna<Key>, class KeyEqual = std::equal_to<Key>>

size_type frozen::unordered_map< Key, Value, N, Hash, KeyEqual >::max_size ( ) const

inlineconstexpr

◆ size()

template<class Key, class Value, std::size_t N, typename Hash = anna<Key>, class KeyEqual = std::equal_to<Key>>

size_type frozen::unordered_map< Key, Value, N, Hash, KeyEqual >::size ( ) const

inlineconstexpr

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

unordered_map.h