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

LIEF: Library to Instrument Executable Formats Version 1.0.0

Loading...

Searching...

No Matches

#include <unordered_set.h>

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

Inheritance graph

[legend]

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

Collaboration graph

[legend]

Public Types
using	key_type = Key
using	value_type = Key
using	size_type = typename container_type::size_type
using	difference_type = typename container_type::difference_type
using	hasher = Hash
using	key_equal = KeyEqual
using	const_reference = typename container_type::const_reference
using	reference = const_reference
using	const_pointer = typename container_type::const_pointer
using	pointer = const_pointer
using	const_iterator = typename container_type::const_iterator
using	iterator = const_iterator

Public Member Functions
	unordered_set (unordered_set const &)=default
constexpr	unordered_set (container_type keys, Hash const &hash, KeyEqual const &equal)
constexpr	unordered_set (container_type keys)
constexpr	unordered_set (std::initializer_list< Key > keys)
constexpr	unordered_set (std::initializer_list< Key > keys, Hash const &hash, KeyEqual const &equal)
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, class Hasher, class Equal>
constexpr const_iterator	find (KeyType const &key, Hasher const &hash, Equal const &equal) const
template<class KeyType>
constexpr const_iterator	find (KeyType const &key) const
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
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, std::size_t N, typename Hash = elsa<Key>, class KeyEqual = std::equal_to<Key>>

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

◆ const_pointer

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

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

◆ const_reference

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

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

◆ difference_type

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

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

◆ hasher

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

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

◆ iterator

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

using frozen::unordered_set< Key, N, Hash, KeyEqual >::iterator = const_iterator

◆ key_equal

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

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

◆ key_type

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

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

◆ pointer

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

using frozen::unordered_set< Key, N, Hash, KeyEqual >::pointer = const_pointer

◆ reference

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

using frozen::unordered_set< Key, N, Hash, KeyEqual >::reference = const_reference

◆ size_type

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

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

◆ value_type

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

using frozen::unordered_set< Key, N, Hash, KeyEqual >::value_type = Key

Constructor & Destructor Documentation

◆ unordered_set() [1/5]

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

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

default

References unordered_set().

Referenced by unordered_set(), unordered_set(), unordered_set(), and unordered_set().

◆ unordered_set() [2/5]

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

frozen::unordered_set< Key, N, Hash, KeyEqual >::unordered_set	(	container_type	keys,
		Hash const &	hash,
		KeyEqual const &	equal )

inlineconstexpr

◆ unordered_set() [3/5]

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

frozen::unordered_set< Key, N, Hash, KeyEqual >::unordered_set ( container_type keys )

inlineexplicitconstexpr

References unordered_set().

◆ unordered_set() [4/5]

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

frozen::unordered_set< Key, N, Hash, KeyEqual >::unordered_set ( std::initializer_list< Key > keys )

inlineconstexpr

References unordered_set().

◆ unordered_set() [5/5]

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

frozen::unordered_set< Key, N, Hash, KeyEqual >::unordered_set	(	std::initializer_list< Key >	keys,
		Hash const &	hash,
		KeyEqual const &	equal )

inlineconstexpr

References unordered_set().

Member Function Documentation

◆ begin()

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

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

inlineconstexpr

◆ bucket_count()

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

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

inlineconstexpr

◆ cbegin()

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

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

inlineconstexpr

◆ cend()

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

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

inlineconstexpr

◆ contains()

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

template<class KeyType>

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

inlineconstexpr

References find().

◆ count()

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

template<class KeyType>

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

inlineconstexpr

References end(), find(), hash_function(), and key_eq().

◆ empty()

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

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

inlineconstexpr

◆ end()

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

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

inlineconstexpr

Referenced by count(), and equal_range().

◆ equal_range()

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

template<class KeyType>

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

inlineconstexpr

References end(), and find().

◆ find() [1/2]

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

template<class KeyType>

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

inlineconstexpr

References hash_function(), and key_eq().

◆ find() [2/2]

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

template<class KeyType, class Hasher, class Equal>

const_iterator frozen::unordered_set< Key, N, Hash, KeyEqual >::find	(	KeyType const &	key,
		Hasher const &	hash,
		Equal const &	equal ) const

inlineconstexpr

Referenced by contains(), count(), and equal_range().

◆ hash_function()

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

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

inlineconstexpr

Referenced by count(), and find().

◆ key_eq()

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

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

inlineconstexpr

Referenced by count(), and find().

◆ max_bucket_count()

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

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

inlineconstexpr

◆ max_size()

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

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

inlineconstexpr

◆ size()

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

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

inlineconstexpr

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

unordered_set.h