LIEF: Library to Instrument Executable Formats: frozen::map< Key, Value, N, Compare > Class Template Reference

LIEF: Library to Instrument Executable Formats Version 1.0.0

Loading...

Searching...

No Matches

#include <map.h>

Inheritance diagram for frozen::map< Key, Value, N, Compare >:

Inheritance graph

[legend]

Collaboration diagram for frozen::map< Key, Value, N, Compare >:

Collaboration graph

[legend]

Public Types
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	key_compare = Compare
using	value_compare = impl::CompareKey<Compare>
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
using	reverse_iterator = std::reverse_iterator<iterator>
using	const_reverse_iterator = std::reverse_iterator<const_iterator>

Public Member Functions
constexpr	map (container_type items, Compare const &compare)
constexpr	map (container_type items)
constexpr	map (std::initializer_list< value_type > items, Compare const &compare)
constexpr	map (std::initializer_list< value_type > items)
constexpr Value const &	at (Key const &key) const
constexpr Value &	at (Key const &key)
constexpr iterator	begin ()
constexpr const_iterator	begin () const
constexpr const_iterator	cbegin () const
constexpr iterator	end ()
constexpr const_iterator	end () const
constexpr const_iterator	cend () const
constexpr reverse_iterator	rbegin ()
constexpr const_reverse_iterator	rbegin () const
constexpr const_reverse_iterator	crbegin () const
constexpr reverse_iterator	rend ()
constexpr const_reverse_iterator	rend () const
constexpr const_reverse_iterator	crend () 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 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)
template<class KeyType>
constexpr const_iterator	lower_bound (KeyType const &key) const
template<class KeyType>
constexpr iterator	lower_bound (KeyType const &key)
template<class KeyType>
constexpr const_iterator	upper_bound (KeyType const &key) const
template<class KeyType>
constexpr iterator	upper_bound (KeyType const &key)
constexpr const key_compare &	key_comp () const
constexpr const value_compare &	value_comp () const

Member Typedef Documentation

◆ const_iterator

template<class Key, class Value, std::size_t N, class Compare = std::less<Key>>

using frozen::map< Key, Value, N, Compare >::const_iterator = typename container_type::const_iterator

◆ const_pointer

template<class Key, class Value, std::size_t N, class Compare = std::less<Key>>

using frozen::map< Key, Value, N, Compare >::const_pointer = typename container_type::const_pointer

◆ const_reference

template<class Key, class Value, std::size_t N, class Compare = std::less<Key>>

using frozen::map< Key, Value, N, Compare >::const_reference = typename container_type::const_reference

◆ const_reverse_iterator

template<class Key, class Value, std::size_t N, class Compare = std::less<Key>>

using frozen::map< Key, Value, N, Compare >::const_reverse_iterator = std::reverse_iterator<const_iterator>

◆ difference_type

template<class Key, class Value, std::size_t N, class Compare = std::less<Key>>

using frozen::map< Key, Value, N, Compare >::difference_type = typename container_type::difference_type

◆ iterator

template<class Key, class Value, std::size_t N, class Compare = std::less<Key>>

using frozen::map< Key, Value, N, Compare >::iterator = typename container_type::iterator

◆ key_compare

template<class Key, class Value, std::size_t N, class Compare = std::less<Key>>

using frozen::map< Key, Value, N, Compare >::key_compare = Compare

◆ key_type

template<class Key, class Value, std::size_t N, class Compare = std::less<Key>>

using frozen::map< Key, Value, N, Compare >::key_type = Key

◆ mapped_type

template<class Key, class Value, std::size_t N, class Compare = std::less<Key>>

using frozen::map< Key, Value, N, Compare >::mapped_type = Value

◆ pointer

template<class Key, class Value, std::size_t N, class Compare = std::less<Key>>

using frozen::map< Key, Value, N, Compare >::pointer = typename container_type::pointer

◆ reference

template<class Key, class Value, std::size_t N, class Compare = std::less<Key>>

using frozen::map< Key, Value, N, Compare >::reference = typename container_type::reference

◆ reverse_iterator

template<class Key, class Value, std::size_t N, class Compare = std::less<Key>>

using frozen::map< Key, Value, N, Compare >::reverse_iterator = std::reverse_iterator<iterator>

◆ size_type

template<class Key, class Value, std::size_t N, class Compare = std::less<Key>>

using frozen::map< Key, Value, N, Compare >::size_type = typename container_type::size_type

◆ value_compare

template<class Key, class Value, std::size_t N, class Compare = std::less<Key>>

using frozen::map< Key, Value, N, Compare >::value_compare = impl::CompareKey<Compare>

◆ value_type

template<class Key, class Value, std::size_t N, class Compare = std::less<Key>>

using frozen::map< Key, Value, N, Compare >::value_type = typename container_type::value_type

Constructor & Destructor Documentation

◆ map() [1/4]

template<class Key, class Value, std::size_t N, class Compare = std::less<Key>>

frozen::map< Key, Value, N, Compare >::map	(	container_type	items,
		Compare const &	compare )

inlineconstexpr

References frozen::impl::CompareKey< Comparator >::CompareKey().

Referenced by map(), map(), and map().

◆ map() [2/4]

template<class Key, class Value, std::size_t N, class Compare = std::less<Key>>

frozen::map< Key, Value, N, Compare >::map ( container_type items )

inlineexplicitconstexpr

References map().

◆ map() [3/4]

template<class Key, class Value, std::size_t N, class Compare = std::less<Key>>

frozen::map< Key, Value, N, Compare >::map	(	std::initializer_list< value_type >	items,
		Compare const &	compare )

inlineconstexpr

References map().

◆ map() [4/4]

template<class Key, class Value, std::size_t N, class Compare = std::less<Key>>

frozen::map< Key, Value, N, Compare >::map ( std::initializer_list< value_type > items )

inlineconstexpr

References map().

Member Function Documentation

◆ at() [1/2]

template<class Key, class Value, std::size_t N, class Compare = std::less<Key>>

Value & frozen::map< Key, Value, N, Compare >::at ( Key const & key )

inlineconstexpr

◆ at() [2/2]

template<class Key, class Value, std::size_t N, class Compare = std::less<Key>>

Value const & frozen::map< Key, Value, N, Compare >::at ( Key const & key ) const

inlineconstexpr

◆ begin() [1/2]

template<class Key, class Value, std::size_t N, class Compare = std::less<Key>>

iterator frozen::map< Key, Value, N, Compare >::begin ( )

inlineconstexpr

◆ begin() [2/2]

template<class Key, class Value, std::size_t N, class Compare = std::less<Key>>

const_iterator frozen::map< Key, Value, N, Compare >::begin ( ) const

inlineconstexpr

◆ cbegin()

template<class Key, class Value, std::size_t N, class Compare = std::less<Key>>

const_iterator frozen::map< Key, Value, N, Compare >::cbegin ( ) const

inlineconstexpr

◆ cend()

template<class Key, class Value, std::size_t N, class Compare = std::less<Key>>

const_iterator frozen::map< Key, Value, N, Compare >::cend ( ) const

inlineconstexpr

◆ contains()

template<class Key, class Value, std::size_t N, class Compare = std::less<Key>>

template<class KeyType>

bool frozen::map< Key, Value, N, Compare >::contains ( KeyType const & key ) const

inlineconstexpr

References end(), and find().

◆ count()

template<class Key, class Value, std::size_t N, class Compare = std::less<Key>>

template<class KeyType>

std::size_t frozen::map< Key, Value, N, Compare >::count ( KeyType const & key ) const

inlineconstexpr

References frozen::bits::binary_search(), and value_comp().

◆ crbegin()

template<class Key, class Value, std::size_t N, class Compare = std::less<Key>>

const_reverse_iterator frozen::map< Key, Value, N, Compare >::crbegin ( ) const

inlineconstexpr

◆ crend()

template<class Key, class Value, std::size_t N, class Compare = std::less<Key>>

const_reverse_iterator frozen::map< Key, Value, N, Compare >::crend ( ) const

inlineconstexpr

◆ empty()

template<class Key, class Value, std::size_t N, class Compare = std::less<Key>>

bool frozen::map< Key, Value, N, Compare >::empty ( ) const

inlineconstexpr

◆ end() [1/2]

template<class Key, class Value, std::size_t N, class Compare = std::less<Key>>

iterator frozen::map< Key, Value, N, Compare >::end ( )

inlineconstexpr

Referenced by contains(), frozen::map< Key, Value, 0, Compare >::equal_range(), frozen::map< Key, Value, 0, Compare >::equal_range(), frozen::map< Key, Value, 0, Compare >::find(), frozen::map< Key, Value, 0, Compare >::find(), frozen::map< Key, Value, 0, Compare >::lower_bound(), frozen::map< Key, Value, 0, Compare >::lower_bound(), frozen::map< Key, Value, 0, Compare >::upper_bound(), and frozen::map< Key, Value, 0, Compare >::upper_bound().

◆ end() [2/2]

template<class Key, class Value, std::size_t N, class Compare = std::less<Key>>

const_iterator frozen::map< Key, Value, N, Compare >::end ( ) const

inlineconstexpr

◆ equal_range() [1/2]

template<class Key, class Value, std::size_t N, class Compare = std::less<Key>>

template<class KeyType>

std::pair< iterator, iterator > frozen::map< Key, Value, N, Compare >::equal_range ( KeyType const & key )

inlineconstexpr

◆ equal_range() [2/2]

template<class Key, class Value, std::size_t N, class Compare = std::less<Key>>

template<class KeyType>

std::pair< const_iterator, const_iterator > frozen::map< Key, Value, N, Compare >::equal_range ( KeyType const & key ) const

inlineconstexpr

◆ find() [1/2]

template<class Key, class Value, std::size_t N, class Compare = std::less<Key>>

template<class KeyType>

iterator frozen::map< Key, Value, N, Compare >::find ( KeyType const & key )

inlineconstexpr

◆ find() [2/2]

template<class Key, class Value, std::size_t N, class Compare = std::less<Key>>

template<class KeyType>

const_iterator frozen::map< Key, Value, N, Compare >::find ( KeyType const & key ) const

inlineconstexpr

Referenced by contains().

◆ key_comp()

template<class Key, class Value, std::size_t N, class Compare = std::less<Key>>

const key_compare & frozen::map< Key, Value, N, Compare >::key_comp ( ) const

inlineconstexpr

References frozen::impl::CompareKey< Comparator >::key_comp(), and value_comp().

◆ lower_bound() [1/2]

template<class Key, class Value, std::size_t N, class Compare = std::less<Key>>

template<class KeyType>

iterator frozen::map< Key, Value, N, Compare >::lower_bound ( KeyType const & key )

inlineconstexpr

◆ lower_bound() [2/2]

template<class Key, class Value, std::size_t N, class Compare = std::less<Key>>

template<class KeyType>

const_iterator frozen::map< Key, Value, N, Compare >::lower_bound ( KeyType const & key ) const

inlineconstexpr

◆ max_size()

template<class Key, class Value, std::size_t N, class Compare = std::less<Key>>

size_type frozen::map< Key, Value, N, Compare >::max_size ( ) const

inlineconstexpr

◆ rbegin() [1/2]

template<class Key, class Value, std::size_t N, class Compare = std::less<Key>>

reverse_iterator frozen::map< Key, Value, N, Compare >::rbegin ( )

inlineconstexpr

◆ rbegin() [2/2]

template<class Key, class Value, std::size_t N, class Compare = std::less<Key>>

const_reverse_iterator frozen::map< Key, Value, N, Compare >::rbegin ( ) const

inlineconstexpr

◆ rend() [1/2]

template<class Key, class Value, std::size_t N, class Compare = std::less<Key>>

reverse_iterator frozen::map< Key, Value, N, Compare >::rend ( )

inlineconstexpr

◆ rend() [2/2]

template<class Key, class Value, std::size_t N, class Compare = std::less<Key>>

const_reverse_iterator frozen::map< Key, Value, N, Compare >::rend ( ) const

inlineconstexpr

◆ size()

template<class Key, class Value, std::size_t N, class Compare = std::less<Key>>

size_type frozen::map< Key, Value, N, Compare >::size ( ) const

inlineconstexpr

◆ upper_bound() [1/2]

template<class Key, class Value, std::size_t N, class Compare = std::less<Key>>

template<class KeyType>

iterator frozen::map< Key, Value, N, Compare >::upper_bound ( KeyType const & key )

inlineconstexpr

◆ upper_bound() [2/2]

template<class Key, class Value, std::size_t N, class Compare = std::less<Key>>

template<class KeyType>

const_iterator frozen::map< Key, Value, N, Compare >::upper_bound ( KeyType const & key ) const

inlineconstexpr

◆ value_comp()

template<class Key, class Value, std::size_t N, class Compare = std::less<Key>>

const value_compare & frozen::map< Key, Value, N, Compare >::value_comp ( ) const

inlineconstexpr

Referenced by count(), key_comp(), and frozen::map< Key, Value, 0, Compare >::key_comp().

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

map.h