A map abstraction with an unsorted std::vector providing O(n) lookup. More...

#include <unordered_flat_map.hpp>

Public Types
using	key_type = Key

using	mapped_type = T

using	value_type = std::pair< Key, T >

using	vector_type = std::vector< value_type, Allocator >

using	allocator_type = typename vector_type::allocator_type

using	size_type = typename vector_type::size_type

using	difference_type = typename vector_type::difference_type

using	reference = typename vector_type::reference

using	const_reference = typename vector_type::const_reference

using	pointer = typename vector_type::pointer

using	const_pointer = typename vector_type::const_pointer

using	iterator = typename vector_type::iterator

using	const_iterator = typename vector_type::const_iterator

using	reverse_iterator = typename vector_type::reverse_iterator

using	const_reverse_iterator = typename vector_type::const_reverse_iterator

Public Member Functions
	unordered_flat_map (std::initializer_list< value_type > l)

template<class InputIterator >
	unordered_flat_map (InputIterator first, InputIterator last)

iterator	begin () noexcept

const_iterator	begin () const noexcept

const_iterator	cbegin () const noexcept

reverse_iterator	rbegin () noexcept

const_reverse_iterator	rbegin () const noexcept

iterator	end () noexcept

const_iterator	end () const noexcept

const_iterator	cend () const noexcept

reverse_iterator	rend () noexcept

const_reverse_iterator	rend () const noexcept

bool	empty () const noexcept

size_type	size () const noexcept

void	reserve (size_type count)

void	shrink_to_fit ()

vector_type &	container () noexcept
	Gives raw access to the underlying container.

const vector_type &	container () const noexcept
	Gives raw access to the underlying container.

void	clear () noexcept

void	swap (unordered_flat_map &other)

std::pair< iterator, bool >	insert (value_type x)

iterator	insert (const_iterator, value_type x)

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

template<class... Ts>
std::pair< iterator, bool >	emplace (Ts &&... xs)

template<class... Ts>
iterator	emplace_hint (const_iterator hint, Ts &&... xs)

std::pair< iterator, bool >	insert_or_assign (const key_type &key, mapped_type val)

iterator	insert_or_assign (const_iterator, const key_type &key, mapped_type val)

iterator	erase (iterator i)

iterator	erase (const_iterator i)

iterator	erase (const_iterator first, const_iterator last)

size_type	erase (const key_type &x)

template<class K >
mapped_type &	at (const K &key)

template<class K >
const mapped_type &	at (const K &key) const

mapped_type &	operator[] (const key_type &key)

template<class K >
iterator	find (const K &key)

template<class K >
const_iterator	find (const K &key) const

template<class K >
size_type	count (const K &key) const

bool	contains (const key_type &key) const

Related Functions
(Note that these are not member functions.)
template<class K , class T , class A >
bool	operator== (const unordered_flat_map< K, T, A > &lhs, const unordered_flat_map< K, T, A > &rhs)

template<class K , class T , class A >
bool	operator!= (const unordered_flat_map< K, T, A > &lhs, const unordered_flat_map< K, T, A > &rhs)

Detailed Description

template<class Key, class T, class Allocator>
class caf::unordered_flat_map< Key, T, Allocator >

A map abstraction with an unsorted std::vector providing O(n) lookup.

Friends And Related Function Documentation

◆ operator!=()

template<class K , class T , class A >

bool operator!=	(	const unordered_flat_map< K, T, A > &	lhs,
		const unordered_flat_map< K, T, A > &	rhs
	)

template<class K , class T , class A >

bool operator==	(	const unordered_flat_map< K, T, A > &	lhs,
		const unordered_flat_map< K, T, A > &	rhs
	)

libcaf_core/caf/fwd.hpp
libcaf_core/caf/unordered_flat_map.hpp

Public Types

Public Member Functions

Related Functions

Detailed Description

template<class Key, class T, class Allocator> class caf::unordered_flat_map< Key, T, Allocator >

Friends And Related Function Documentation

◆ operator!=()

◆ operator==()

template<class Key, class T, class Allocator>
class caf::unordered_flat_map< Key, T, Allocator >