An optimized map with Direction keys. More...

#include <DirectionMap.hpp>

Public Types
using	base = FixedHashMap< 2 *Dim, Direction< Dim >, T, DirectionHash< Dim > >

Public Types inherited from FixedHashMap< 2 *Dim, Direction< Dim >, T, DirectionHash< Dim > >
using	key_type = Direction< Dim >

using	mapped_type = T

using	value_type = std::pair< const key_type, mapped_type >

using	size_type = size_t

using	difference_type = ptrdiff_t

using	hasher = DirectionHash< Dim >

using	key_equal = std::equal_to< Direction< Dim > >

using	reference = value_type &

using	const_reference = const value_type &

using	pointer = value_type *

using	const_pointer = const value_type *

using	iterator = FixedHashMapIterator< MaxSize, key_type, value_type, hasher, key_equal >

using	const_iterator = FixedHashMapIterator< MaxSize, key_type, const value_type, hasher, key_equal >

Additional Inherited Members
Public Member Functions inherited from FixedHashMap< 2 *Dim, Direction< Dim >, T, DirectionHash< Dim > >
	FixedHashMap (std::initializer_list< value_type > init)

	FixedHashMap (const FixedHashMap &)=default

	FixedHashMap (FixedHashMap &&)=default

FixedHashMap &	operator= (const FixedHashMap &other)

FixedHashMap &	operator= (FixedHashMap &&other)

iterator	begin ()

const_iterator	begin () const

const_iterator	cbegin () const

iterator	end ()

const_iterator	end () const

const_iterator	cend () const

bool	empty () const

size_t	size () const

void	clear ()

iterator	erase (const const_iterator &pos)

size_t	erase (const key_type &key)

mapped_type &	at (const key_type &key)

const mapped_type &	at (const key_type &key) const

mapped_type &	operator[] (const key_type &key)

size_t	count (const key_type &key) const

iterator	find (const key_type &key)

const_iterator	find (const key_type &key) const

bool	contains (const key_type &key) const
	Check if `key` is in the map.

key_equal	key_eq () const
	Get key equal function object.

hasher	hash_function () const
	Get hash function object.

void	pup (PUP::er &p)

auto	insert_or_assign_impl (key_type &&key, M &&obj) -> std::pair< iterator, bool >

auto	get_data_entry (const Direction< Dim > &key) -> typename storage_type::iterator

std::pair< iterator, bool >	insert (const value_type &value)
	Inserts the element if it does not exists.

std::pair< iterator, bool >	insert (value_type &&value)
	Inserts the element if it does not exists.

std::pair< iterator, bool >	emplace (Args &&... args)
	Inserts the element if it does not exists.

std::pair< iterator, bool >	insert_or_assign (const key_type &key, M &&obj)
	Inserts the element if it does not exists, otherwise assigns to it the new value.

std::pair< iterator, bool >	insert_or_assign (key_type &&key, M &&obj)
	Inserts the element if it does not exists, otherwise assigns to it the new value.

Detailed Description

template<size_t Dim, typename T>
class DirectionMap< Dim, T >

An optimized map with Direction keys.

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

src/Domain/Structure/DirectionMap.hpp

Public Types

Additional Inherited Members

Detailed Description