FlatMap is an almsot drop-in replacement of Map. More...

#include <CeresEngine/Foundation/Container/FlatMap.hpp>

Classes
struct	pair_compare

Public Types
using	key_type = Key

using	mapped_type = T

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

using	container_type = Container

using	key_compare = Compare

using	reference = value_type &

using	const_reference = const value_type &

using	allocator_type = typename container_type::allocator_type

using	pointer = typename std::allocator_traits< allocator_type >::pointer

using	const_pointer = typename std::allocator_traits< allocator_type >::pointer

using	iterator = typename container_type::iterator

using	const_iterator = typename container_type::const_iterator

using	reverse_iterator = typename container_type::reverse_iterator

using	const_reverse_iterator = typename container_type::const_reverse_iterator

using	difference_type = typename container_type::difference_type

using	size_type = typename container_type::size_type

Public Member Functions
	FlatMap ()

	FlatMap (const key_compare &comp, const allocator_type &alloc=allocator_type())

	FlatMap (const FlatMap &x)=default

	FlatMap (FlatMap &&x)=default

FlatMap &	operator= (const FlatMap &x)

FlatMap &	operator= (FlatMap &&x)

iterator	begin () noexcept

const_iterator	begin () const noexcept

iterator	end () noexcept

const_iterator	end () const noexcept

reverse_iterator	rbegin () noexcept

const_reverse_iterator	rbegin () const noexcept

reverse_iterator	rend () noexcept

const_reverse_iterator	rend () const noexcept

const_iterator	cbegin () const noexcept

const_iterator	cend () const noexcept

bool	empty () const noexcept

size_type	size () const noexcept

size_type	max_size () const noexcept

void	reserve (size_type count)

size_type	capacity () const noexcept

void	clear () noexcept

template<typename K = key_type>
iterator	lower_bound (const K &k)

template<typename K = key_type>
const_iterator	lower_bound (const K &k) const

template<typename K = key_type>
iterator	find (const K &k)

template<typename K = key_type>
const_iterator	find (const K &k) const

template<typename K = key_type>
size_t	count (const K &k) const

template<typename P >
std::pair< iterator, bool >	insert (P &&val)

std::pair< iterator, bool >	insert (const value_type &val)

template<typename... Args>
std::pair< iterator, bool >	emplace (Args &&... args)

iterator	erase (iterator pos)

iterator	erase (const_iterator pos)

template<typename K = key_type>
size_type	erase (const K &k)

template<typename K = key_type>
mapped_type &	operator[] (const K &k)

template<typename K = key_type>
mapped_type &	operator[] (K &&k)

template<typename K = key_type>
mapped_type &	at (const K &k)

template<typename K = key_type>
const mapped_type &	at (const K &k) const

void	swap (FlatMap &x)

const container_type &	container () const noexcept

container_type &	modify_container () noexcept

Private Attributes
pair_compare	m_cmp

container_type	m_container

Detailed Description

template<typename Key, typename T, typename Compare = std::less<>, typename Container = Vector<Pair<Key, T>>>
class CeresEngine::FlatMap< Key, T, Compare, Container >

FlatMap is an almsot drop-in replacement of Map.

Flat map has an optional underlying container which by default is Vector. Thus the items in the map are in a continuous block of memory. Thus iterating over the map is cache friendly, at the cost of O(n) for insert and erase.

The elements inside (like in Map ) are kept in an order sorted by key. Getting a value by key is O(log2 n). It generally performs much faster than Map for smaller sets of elements.

The difference with Map, which makes FlatMap an not-exactly-drop-in replacement is the last template argument:

Map has <Key, Value, Compare, Allocator>
FlatMap has <Key, Value, Compare, Container>

The container must be an Vector compatible type (SmallVector is, for example, viable). The container value type must be Pair<Key, Value>.

             Changing the allocator.

If you want to change the allocator of flat map, you'll have to provide a container with the appropriate one. Example:

FlatMap< String, Int32, std::less<String>, Vector<Pair<String, Int>, MyAllocator>

‍myMap

Member Typedef Documentation

◆ allocator_type

template<typename Key , typename T , typename Compare = std::less<>, typename Container = Vector<Pair<Key, T>>>

using CeresEngine::FlatMap< Key, T, Compare, Container >::allocator_type = typename container_type::allocator_type

◆ const_iterator

template<typename Key , typename T , typename Compare = std::less<>, typename Container = Vector<Pair<Key, T>>>

using CeresEngine::FlatMap< Key, T, Compare, Container >::const_iterator = typename container_type::const_iterator

◆ const_pointer

template<typename Key , typename T , typename Compare = std::less<>, typename Container = Vector<Pair<Key, T>>>

using CeresEngine::FlatMap< Key, T, Compare, Container >::const_pointer = typename std::allocator_traits<allocator_type>::pointer

◆ const_reference

template<typename Key , typename T , typename Compare = std::less<>, typename Container = Vector<Pair<Key, T>>>

using CeresEngine::FlatMap< Key, T, Compare, Container >::const_reference = const value_type&

◆ const_reverse_iterator

template<typename Key , typename T , typename Compare = std::less<>, typename Container = Vector<Pair<Key, T>>>

using CeresEngine::FlatMap< Key, T, Compare, Container >::const_reverse_iterator = typename container_type::const_reverse_iterator

◆ container_type

template<typename Key , typename T , typename Compare = std::less<>, typename Container = Vector<Pair<Key, T>>>

using CeresEngine::FlatMap< Key, T, Compare, Container >::container_type = Container

◆ difference_type

template<typename Key , typename T , typename Compare = std::less<>, typename Container = Vector<Pair<Key, T>>>

using CeresEngine::FlatMap< Key, T, Compare, Container >::difference_type = typename container_type::difference_type

◆ iterator

template<typename Key , typename T , typename Compare = std::less<>, typename Container = Vector<Pair<Key, T>>>

using CeresEngine::FlatMap< Key, T, Compare, Container >::iterator = typename container_type::iterator

◆ key_compare

template<typename Key , typename T , typename Compare = std::less<>, typename Container = Vector<Pair<Key, T>>>

using CeresEngine::FlatMap< Key, T, Compare, Container >::key_compare = Compare

◆ key_type

template<typename Key , typename T , typename Compare = std::less<>, typename Container = Vector<Pair<Key, T>>>

using CeresEngine::FlatMap< Key, T, Compare, Container >::key_type = Key

◆ mapped_type

template<typename Key , typename T , typename Compare = std::less<>, typename Container = Vector<Pair<Key, T>>>

using CeresEngine::FlatMap< Key, T, Compare, Container >::mapped_type = T

◆ pointer

template<typename Key , typename T , typename Compare = std::less<>, typename Container = Vector<Pair<Key, T>>>

using CeresEngine::FlatMap< Key, T, Compare, Container >::pointer = typename std::allocator_traits<allocator_type>::pointer

◆ reference

template<typename Key , typename T , typename Compare = std::less<>, typename Container = Vector<Pair<Key, T>>>

using CeresEngine::FlatMap< Key, T, Compare, Container >::reference = value_type&

◆ reverse_iterator

template<typename Key , typename T , typename Compare = std::less<>, typename Container = Vector<Pair<Key, T>>>

using CeresEngine::FlatMap< Key, T, Compare, Container >::reverse_iterator = typename container_type::reverse_iterator

◆ size_type

template<typename Key , typename T , typename Compare = std::less<>, typename Container = Vector<Pair<Key, T>>>

using CeresEngine::FlatMap< Key, T, Compare, Container >::size_type = typename container_type::size_type

◆ value_type

template<typename Key , typename T , typename Compare = std::less<>, typename Container = Vector<Pair<Key, T>>>

using CeresEngine::FlatMap< Key, T, Compare, Container >::value_type = std::pair<Key, T>

Constructor & Destructor Documentation

◆ FlatMap() [1/4]

template<typename Key , typename T , typename Compare = std::less<>, typename Container = Vector<Pair<Key, T>>>

CeresEngine::FlatMap< Key, T, Compare, Container >::FlatMap ( )

inline

◆ FlatMap() [2/4]

template<typename Key , typename T , typename Compare = std::less<>, typename Container = Vector<Pair<Key, T>>>

CeresEngine::FlatMap< Key, T, Compare, Container >::FlatMap	(	const key_compare &	comp,
		const allocator_type &	alloc = `allocator_type()`
	)

inlineexplicit

◆ FlatMap() [3/4]

template<typename Key , typename T , typename Compare = std::less<>, typename Container = Vector<Pair<Key, T>>>

CeresEngine::FlatMap< Key, T, Compare, Container >::FlatMap ( const FlatMap< Key, T, Compare, Container > & x )

default

◆ FlatMap() [4/4]

template<typename Key , typename T , typename Compare = std::less<>, typename Container = Vector<Pair<Key, T>>>

CeresEngine::FlatMap< Key, T, Compare, Container >::FlatMap ( FlatMap< Key, T, Compare, Container > && x )

default

Member Function Documentation

◆ at() [1/2]

template<typename Key , typename T , typename Compare = std::less<>, typename Container = Vector<Pair<Key, T>>>

template<typename K = key_type>

mapped_type & CeresEngine::FlatMap< Key, T, Compare, Container >::at ( const K & k )

inline

◆ at() [2/2]

template<typename Key , typename T , typename Compare = std::less<>, typename Container = Vector<Pair<Key, T>>>

template<typename K = key_type>

const mapped_type & CeresEngine::FlatMap< Key, T, Compare, Container >::at ( const K & k ) const

inline

◆ begin() [1/2]

template<typename Key , typename T , typename Compare = std::less<>, typename Container = Vector<Pair<Key, T>>>

const_iterator CeresEngine::FlatMap< Key, T, Compare, Container >::begin ( ) const

inlinenoexcept

◆ begin() [2/2]

template<typename Key , typename T , typename Compare = std::less<>, typename Container = Vector<Pair<Key, T>>>

iterator CeresEngine::FlatMap< Key, T, Compare, Container >::begin ( )

inlinenoexcept

◆ capacity()

template<typename Key , typename T , typename Compare = std::less<>, typename Container = Vector<Pair<Key, T>>>

size_type CeresEngine::FlatMap< Key, T, Compare, Container >::capacity ( ) const

inlinenoexcept

◆ cbegin()

template<typename Key , typename T , typename Compare = std::less<>, typename Container = Vector<Pair<Key, T>>>

const_iterator CeresEngine::FlatMap< Key, T, Compare, Container >::cbegin ( ) const

inlinenoexcept

◆ cend()

template<typename Key , typename T , typename Compare = std::less<>, typename Container = Vector<Pair<Key, T>>>

const_iterator CeresEngine::FlatMap< Key, T, Compare, Container >::cend ( ) const

inlinenoexcept

◆ clear()

template<typename Key , typename T , typename Compare = std::less<>, typename Container = Vector<Pair<Key, T>>>

void CeresEngine::FlatMap< Key, T, Compare, Container >::clear ( )

inlinenoexcept

◆ container()

template<typename Key , typename T , typename Compare = std::less<>, typename Container = Vector<Pair<Key, T>>>

const container_type & CeresEngine::FlatMap< Key, T, Compare, Container >::container ( ) const

inlinenoexcept

◆ count()

template<typename Key , typename T , typename Compare = std::less<>, typename Container = Vector<Pair<Key, T>>>

template<typename K = key_type>

size_t CeresEngine::FlatMap< Key, T, Compare, Container >::count ( const K & k ) const

inline

◆ emplace()

template<typename Key , typename T , typename Compare = std::less<>, typename Container = Vector<Pair<Key, T>>>

template<typename... Args>

std::pair< iterator, bool > CeresEngine::FlatMap< Key, T, Compare, Container >::emplace ( Args &&... args )

inline

◆ empty()

template<typename Key , typename T , typename Compare = std::less<>, typename Container = Vector<Pair<Key, T>>>

bool CeresEngine::FlatMap< Key, T, Compare, Container >::empty ( ) const

inlinenoexcept

◆ end() [1/2]

template<typename Key , typename T , typename Compare = std::less<>, typename Container = Vector<Pair<Key, T>>>

const_iterator CeresEngine::FlatMap< Key, T, Compare, Container >::end ( ) const

inlinenoexcept

◆ end() [2/2]

template<typename Key , typename T , typename Compare = std::less<>, typename Container = Vector<Pair<Key, T>>>

iterator CeresEngine::FlatMap< Key, T, Compare, Container >::end ( )

inlinenoexcept

◆ erase() [1/3]

template<typename Key , typename T , typename Compare = std::less<>, typename Container = Vector<Pair<Key, T>>>

template<typename K = key_type>

size_type CeresEngine::FlatMap< Key, T, Compare, Container >::erase ( const K & k )

inline

◆ erase() [2/3]

template<typename Key , typename T , typename Compare = std::less<>, typename Container = Vector<Pair<Key, T>>>

iterator CeresEngine::FlatMap< Key, T, Compare, Container >::erase ( const_iterator pos )

inline

◆ erase() [3/3]

template<typename Key , typename T , typename Compare = std::less<>, typename Container = Vector<Pair<Key, T>>>

iterator CeresEngine::FlatMap< Key, T, Compare, Container >::erase ( iterator pos )

inline

◆ find() [1/2]

template<typename Key , typename T , typename Compare = std::less<>, typename Container = Vector<Pair<Key, T>>>

template<typename K = key_type>

iterator CeresEngine::FlatMap< Key, T, Compare, Container >::find ( const K & k )

inline

◆ find() [2/2]

template<typename Key , typename T , typename Compare = std::less<>, typename Container = Vector<Pair<Key, T>>>

template<typename K = key_type>

const_iterator CeresEngine::FlatMap< Key, T, Compare, Container >::find ( const K & k ) const

inline

◆ insert() [1/2]

template<typename Key , typename T , typename Compare = std::less<>, typename Container = Vector<Pair<Key, T>>>

std::pair< iterator, bool > CeresEngine::FlatMap< Key, T, Compare, Container >::insert ( const value_type & val )

inline

◆ insert() [2/2]

template<typename Key , typename T , typename Compare = std::less<>, typename Container = Vector<Pair<Key, T>>>

template<typename P >

std::pair< iterator, bool > CeresEngine::FlatMap< Key, T, Compare, Container >::insert ( P && val )

inline

◆ lower_bound() [1/2]

template<typename Key , typename T , typename Compare = std::less<>, typename Container = Vector<Pair<Key, T>>>

template<typename K = key_type>

iterator CeresEngine::FlatMap< Key, T, Compare, Container >::lower_bound ( const K & k )

inline

◆ lower_bound() [2/2]

template<typename Key , typename T , typename Compare = std::less<>, typename Container = Vector<Pair<Key, T>>>

template<typename K = key_type>

const_iterator CeresEngine::FlatMap< Key, T, Compare, Container >::lower_bound ( const K & k ) const

inline

◆ max_size()

template<typename Key , typename T , typename Compare = std::less<>, typename Container = Vector<Pair<Key, T>>>

size_type CeresEngine::FlatMap< Key, T, Compare, Container >::max_size ( ) const

inlinenoexcept

◆ modify_container()

template<typename Key , typename T , typename Compare = std::less<>, typename Container = Vector<Pair<Key, T>>>

container_type & CeresEngine::FlatMap< Key, T, Compare, Container >::modify_container ( )

inlinenoexcept

◆ operator=() [1/2]

template<typename Key , typename T , typename Compare = std::less<>, typename Container = Vector<Pair<Key, T>>>

FlatMap & CeresEngine::FlatMap< Key, T, Compare, Container >::operator= ( const FlatMap< Key, T, Compare, Container > & x )

inline

◆ operator=() [2/2]

template<typename Key , typename T , typename Compare = std::less<>, typename Container = Vector<Pair<Key, T>>>

FlatMap & CeresEngine::FlatMap< Key, T, Compare, Container >::operator= ( FlatMap< Key, T, Compare, Container > && x )

inline

◆ operator[]() [1/2]

template<typename Key , typename T , typename Compare = std::less<>, typename Container = Vector<Pair<Key, T>>>

template<typename K = key_type>

mapped_type & CeresEngine::FlatMap< Key, T, Compare, Container >::operator[] ( const K & k )

inline

◆ operator[]() [2/2]

template<typename Key , typename T , typename Compare = std::less<>, typename Container = Vector<Pair<Key, T>>>

template<typename K = key_type>

mapped_type & CeresEngine::FlatMap< Key, T, Compare, Container >::operator[] ( K && k )

inline

◆ rbegin() [1/2]

template<typename Key , typename T , typename Compare = std::less<>, typename Container = Vector<Pair<Key, T>>>

const_reverse_iterator CeresEngine::FlatMap< Key, T, Compare, Container >::rbegin ( ) const

inlinenoexcept

◆ rbegin() [2/2]

template<typename Key , typename T , typename Compare = std::less<>, typename Container = Vector<Pair<Key, T>>>

reverse_iterator CeresEngine::FlatMap< Key, T, Compare, Container >::rbegin ( )

inlinenoexcept

◆ rend() [1/2]

template<typename Key , typename T , typename Compare = std::less<>, typename Container = Vector<Pair<Key, T>>>

const_reverse_iterator CeresEngine::FlatMap< Key, T, Compare, Container >::rend ( ) const

inlinenoexcept

◆ rend() [2/2]

template<typename Key , typename T , typename Compare = std::less<>, typename Container = Vector<Pair<Key, T>>>

reverse_iterator CeresEngine::FlatMap< Key, T, Compare, Container >::rend ( )

inlinenoexcept

◆ reserve()

template<typename Key , typename T , typename Compare = std::less<>, typename Container = Vector<Pair<Key, T>>>

void CeresEngine::FlatMap< Key, T, Compare, Container >::reserve ( size_type count )

inline

◆ size()

template<typename Key , typename T , typename Compare = std::less<>, typename Container = Vector<Pair<Key, T>>>

size_type CeresEngine::FlatMap< Key, T, Compare, Container >::size ( ) const

inlinenoexcept

◆ swap()

template<typename Key , typename T , typename Compare = std::less<>, typename Container = Vector<Pair<Key, T>>>

void CeresEngine::FlatMap< Key, T, Compare, Container >::swap ( FlatMap< Key, T, Compare, Container > & x )

inline

Member Data Documentation

◆ m_cmp

template<typename Key , typename T , typename Compare = std::less<>, typename Container = Vector<Pair<Key, T>>>

pair_compare CeresEngine::FlatMap< Key, T, Compare, Container >::m_cmp

private

◆ m_container

template<typename Key , typename T , typename Compare = std::less<>, typename Container = Vector<Pair<Key, T>>>

container_type CeresEngine::FlatMap< Key, T, Compare, Container >::m_container

private

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

/Users/Rogiel/Developer/CeresEngine/Engine/Sources/CeresEngine/Foundation/Container/FlatMap.hpp

Classes

Public Types

Public Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

◆ allocator_type

◆ const_iterator

◆ const_pointer

◆ const_reference

◆ const_reverse_iterator

◆ container_type

◆ difference_type

◆ iterator

◆ key_compare

◆ key_type

◆ mapped_type

◆ pointer

◆ reference

◆ reverse_iterator

◆ size_type

◆ value_type

Constructor & Destructor Documentation

◆ FlatMap() [1/4]

◆ FlatMap() [2/4]

◆ FlatMap() [3/4]

◆ FlatMap() [4/4]

Member Function Documentation

◆ at() [1/2]

◆ at() [2/2]

◆ begin() [1/2]

◆ begin() [2/2]

◆ capacity()

◆ cbegin()

◆ cend()

◆ clear()

◆ container()

◆ count()

◆ emplace()

◆ empty()

◆ end() [1/2]

◆ end() [2/2]

◆ erase() [1/3]

◆ erase() [2/3]

◆ erase() [3/3]

◆ find() [1/2]

◆ find() [2/2]

◆ insert() [1/2]

◆ insert() [2/2]

◆ lower_bound() [1/2]

◆ lower_bound() [2/2]

◆ max_size()

◆ modify_container()

◆ operator=() [1/2]

◆ operator=() [2/2]

◆ operator[]() [1/2]

◆ operator[]() [2/2]

◆ rbegin() [1/2]

◆ rbegin() [2/2]

◆ rend() [1/2]

◆ rend() [2/2]

◆ reserve()

◆ size()

◆ swap()

Member Data Documentation

◆ m_cmp

◆ m_container