#include <JPLSpatial/Containers/FlatMap.h>

Public Types
using	allocator_type = KeyContainer::allocator_type

using	key_type = Key

using	mapped_type = T

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

using	key_compare = Equals

using	key_container_type = KeyContainer

using	mapped_container_type = MappedContainer

using	size_type = std::size_t

using	difference_type = std::ptrdiff_t

using	reference = std::pair< const key_type &, mapped_type & >

using	const_reference = std::pair< const key_type &, const mapped_type & >

using	iterator = zip_iter< const Key, T >

using	const_iterator = zip_iter< const Key, const T >

Public Member Functions
	FlatMap (const FlatMap &)=default

	FlatMap (FlatMap &&) noexcept=default

FlatMap &	operator= (const FlatMap &)=default

FlatMap &	operator= (FlatMap &&) noexcept=default

	~FlatMap ()=default

	FlatMap ()=default

	FlatMap (const allocator_type &allocator)

	FlatMap (Equals eq, const allocator_type &allocator={})

template<class InputIter >
	FlatMap (InputIter first, InputIter last, Equals eq={}, const allocator_type &allocator={})

	FlatMap (std::initializer_list< value_type > init, const allocator_type &allocator={})

JPL_INLINE const key_container_type &	keys () const noexcept

JPL_INLINE const mapped_container_type &	values () const noexcept

JPL_INLINE void	reserve (std::size_t n)

JPL_INLINE size_type	size () const

JPL_INLINE bool	empty () const

JPL_INLINE iterator	begin () noexcept

JPL_INLINE iterator	end () noexcept

JPL_INLINE const_iterator	begin () const noexcept

JPL_INLINE const_iterator	end () const noexcept

JPL_INLINE const_iterator	cbegin () const noexcept

JPL_INLINE const_iterator	cend () const noexcept

JPL_INLINE void	push_back (const Key &k, const T &v)

JPL_INLINE iterator	find (const Key &key)

JPL_INLINE const_iterator	find (const Key &key) const

template<class K2 > requires (EqComparable<Key, K2> \|\| EqComparable<K2, Key>)
JPL_INLINE iterator	find (const K2 &key_like)

template<class K2 > requires (EqComparable<Key, K2> \|\| EqComparable<K2, Key>)
JPL_INLINE const_iterator	find (const K2 &key_like) const

JPL_INLINE mapped_type &	at (const Key &key)

JPL_INLINE const mapped_type &	at (const Key &key) const

JPL_INLINE mapped_type &	operator[] (const Key &key)

JPL_INLINE mapped_type &	operator[] (Key &&key)

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

JPL_INLINE size_t	erase (const_iterator iter)

JPL_INLINE size_t	erase (iterator it)

JPL_INLINE size_t	erase (const Key &key)

template<class K2 > requires (EqComparable<Key, K2> \|\| EqComparable<K2, Key>)
JPL_INLINE size_t	erase (const K2 &key_like)

template<class Predicate >
JPL_INLINE size_t	erase_if (Predicate &&pred)

JPL_INLINE bool	contains (const Key &key) const

template<class K2 > requires (EqComparable<Key, K2> \|\| EqComparable<K2, Key>)
JPL_INLINE bool	contains (const K2 &key_like) const

Friends
void	swap (FlatMap &a, FlatMap &b) noexcept(noexcept(std::swap(a.cont.keys, b.cont.keys)) &&noexcept(std::swap(a.cont.values, b.cont.values)) &&noexcept(std::swap(a.eq, b.eq)))

Member Typedef Documentation

◆ allocator_type

template<class Key , class T , class Equals = std::equal_to<Key>, class KeyContainer = std::vector<Key>, class MappedContainer = std::vector<T>>

using JPL::FlatMap< Key, T, Equals, KeyContainer, MappedContainer >::allocator_type = KeyContainer::allocator_type

◆ const_iterator

template<class Key , class T , class Equals = std::equal_to<Key>, class KeyContainer = std::vector<Key>, class MappedContainer = std::vector<T>>

using JPL::FlatMap< Key, T, Equals, KeyContainer, MappedContainer >::const_iterator = zip_iter<const Key, const T>

◆ const_reference

template<class Key , class T , class Equals = std::equal_to<Key>, class KeyContainer = std::vector<Key>, class MappedContainer = std::vector<T>>

using JPL::FlatMap< Key, T, Equals, KeyContainer, MappedContainer >::const_reference = std::pair<const key_type&, const mapped_type&>

◆ difference_type

template<class Key , class T , class Equals = std::equal_to<Key>, class KeyContainer = std::vector<Key>, class MappedContainer = std::vector<T>>

using JPL::FlatMap< Key, T, Equals, KeyContainer, MappedContainer >::difference_type = std::ptrdiff_t

◆ iterator

template<class Key , class T , class Equals = std::equal_to<Key>, class KeyContainer = std::vector<Key>, class MappedContainer = std::vector<T>>

using JPL::FlatMap< Key, T, Equals, KeyContainer, MappedContainer >::iterator = zip_iter<const Key, T>

◆ key_compare

template<class Key , class T , class Equals = std::equal_to<Key>, class KeyContainer = std::vector<Key>, class MappedContainer = std::vector<T>>

using JPL::FlatMap< Key, T, Equals, KeyContainer, MappedContainer >::key_compare = Equals

◆ key_container_type

template<class Key , class T , class Equals = std::equal_to<Key>, class KeyContainer = std::vector<Key>, class MappedContainer = std::vector<T>>

using JPL::FlatMap< Key, T, Equals, KeyContainer, MappedContainer >::key_container_type = KeyContainer

◆ key_type

template<class Key , class T , class Equals = std::equal_to<Key>, class KeyContainer = std::vector<Key>, class MappedContainer = std::vector<T>>

using JPL::FlatMap< Key, T, Equals, KeyContainer, MappedContainer >::key_type = Key

◆ mapped_container_type

template<class Key , class T , class Equals = std::equal_to<Key>, class KeyContainer = std::vector<Key>, class MappedContainer = std::vector<T>>

using JPL::FlatMap< Key, T, Equals, KeyContainer, MappedContainer >::mapped_container_type = MappedContainer

◆ mapped_type

template<class Key , class T , class Equals = std::equal_to<Key>, class KeyContainer = std::vector<Key>, class MappedContainer = std::vector<T>>

using JPL::FlatMap< Key, T, Equals, KeyContainer, MappedContainer >::mapped_type = T

◆ reference

template<class Key , class T , class Equals = std::equal_to<Key>, class KeyContainer = std::vector<Key>, class MappedContainer = std::vector<T>>

using JPL::FlatMap< Key, T, Equals, KeyContainer, MappedContainer >::reference = std::pair<const key_type&, mapped_type&>

◆ size_type

template<class Key , class T , class Equals = std::equal_to<Key>, class KeyContainer = std::vector<Key>, class MappedContainer = std::vector<T>>

using JPL::FlatMap< Key, T, Equals, KeyContainer, MappedContainer >::size_type = std::size_t

◆ value_type

template<class Key , class T , class Equals = std::equal_to<Key>, class KeyContainer = std::vector<Key>, class MappedContainer = std::vector<T>>

using JPL::FlatMap< Key, T, Equals, KeyContainer, MappedContainer >::value_type = std::pair<key_type, mapped_type>

Constructor & Destructor Documentation

◆ FlatMap() [1/7]

template<class Key , class T , class Equals = std::equal_to<Key>, class KeyContainer = std::vector<Key>, class MappedContainer = std::vector<T>>

JPL::FlatMap< Key, T, Equals, KeyContainer, MappedContainer >::FlatMap ( const FlatMap< Key, T, Equals, KeyContainer, MappedContainer > & )

default

◆ FlatMap() [2/7]

template<class Key , class T , class Equals = std::equal_to<Key>, class KeyContainer = std::vector<Key>, class MappedContainer = std::vector<T>>

JPL::FlatMap< Key, T, Equals, KeyContainer, MappedContainer >::FlatMap ( FlatMap< Key, T, Equals, KeyContainer, MappedContainer > && )

defaultnoexcept

◆ ~FlatMap()

template<class Key , class T , class Equals = std::equal_to<Key>, class KeyContainer = std::vector<Key>, class MappedContainer = std::vector<T>>

JPL::FlatMap< Key, T, Equals, KeyContainer, MappedContainer >::~FlatMap ( )

default

◆ FlatMap() [3/7]

template<class Key , class T , class Equals = std::equal_to<Key>, class KeyContainer = std::vector<Key>, class MappedContainer = std::vector<T>>

JPL::FlatMap< Key, T, Equals, KeyContainer, MappedContainer >::FlatMap ( )

default

◆ FlatMap() [4/7]

template<class Key , class T , class Equals = std::equal_to<Key>, class KeyContainer = std::vector<Key>, class MappedContainer = std::vector<T>>

JPL::FlatMap< Key, T, Equals, KeyContainer, MappedContainer >::FlatMap ( const allocator_type & allocator )

inlineexplicit

◆ FlatMap() [5/7]

template<class Key , class T , class Equals = std::equal_to<Key>, class KeyContainer = std::vector<Key>, class MappedContainer = std::vector<T>>

JPL::FlatMap< Key, T, Equals, KeyContainer, MappedContainer >::FlatMap	(	Equals	eq,
		const allocator_type &	allocator = `{}`
	)

inline

◆ FlatMap() [6/7]

template<class Key , class T , class Equals = std::equal_to<Key>, class KeyContainer = std::vector<Key>, class MappedContainer = std::vector<T>>

template<class InputIter >

JPL::FlatMap< Key, T, Equals, KeyContainer, MappedContainer >::FlatMap	(	InputIter	first,
		InputIter	last,
		Equals	eq = `{}`,
		const allocator_type &	allocator = `{}`
	)

inline

◆ FlatMap() [7/7]

template<class Key , class T , class Equals = std::equal_to<Key>, class KeyContainer = std::vector<Key>, class MappedContainer = std::vector<T>>

JPL::FlatMap< Key, T, Equals, KeyContainer, MappedContainer >::FlatMap	(	std::initializer_list< value_type >	init,
		const allocator_type &	allocator = `{}`
	)

inlineexplicit

Member Function Documentation

◆ at() [1/2]

template<class Key , class T , class Equals = std::equal_to<Key>, class KeyContainer = std::vector<Key>, class MappedContainer = std::vector<T>>

JPL_INLINE mapped_type & JPL::FlatMap< Key, T, Equals, KeyContainer, MappedContainer >::at ( const Key & key )

inline

◆ at() [2/2]

template<class Key , class T , class Equals = std::equal_to<Key>, class KeyContainer = std::vector<Key>, class MappedContainer = std::vector<T>>

JPL_INLINE const mapped_type & JPL::FlatMap< Key, T, Equals, KeyContainer, MappedContainer >::at ( const Key & key ) const

inline

◆ begin() [1/2]

template<class Key , class T , class Equals = std::equal_to<Key>, class KeyContainer = std::vector<Key>, class MappedContainer = std::vector<T>>

JPL_INLINE const_iterator JPL::FlatMap< Key, T, Equals, KeyContainer, MappedContainer >::begin ( ) const

inlinenoexcept

◆ begin() [2/2]

template<class Key , class T , class Equals = std::equal_to<Key>, class KeyContainer = std::vector<Key>, class MappedContainer = std::vector<T>>

JPL_INLINE iterator JPL::FlatMap< Key, T, Equals, KeyContainer, MappedContainer >::begin ( )

inlinenoexcept

◆ cbegin()

template<class Key , class T , class Equals = std::equal_to<Key>, class KeyContainer = std::vector<Key>, class MappedContainer = std::vector<T>>

JPL_INLINE const_iterator JPL::FlatMap< Key, T, Equals, KeyContainer, MappedContainer >::cbegin ( ) const

inlinenoexcept

◆ cend()

template<class Key , class T , class Equals = std::equal_to<Key>, class KeyContainer = std::vector<Key>, class MappedContainer = std::vector<T>>

JPL_INLINE const_iterator JPL::FlatMap< Key, T, Equals, KeyContainer, MappedContainer >::cend ( ) const

inlinenoexcept

◆ contains() [1/2]

template<class Key , class T , class Equals = std::equal_to<Key>, class KeyContainer = std::vector<Key>, class MappedContainer = std::vector<T>>

template<class K2 >
requires (EqComparable<Key, K2> || EqComparable<K2, Key>)

JPL_INLINE bool JPL::FlatMap< Key, T, Equals, KeyContainer, MappedContainer >::contains ( const K2 & key_like ) const

inline

◆ contains() [2/2]

template<class Key , class T , class Equals = std::equal_to<Key>, class KeyContainer = std::vector<Key>, class MappedContainer = std::vector<T>>

JPL_INLINE bool JPL::FlatMap< Key, T, Equals, KeyContainer, MappedContainer >::contains ( const Key & key ) const

inline

◆ emplace()

template<class Key , class T , class Equals = std::equal_to<Key>, class KeyContainer = std::vector<Key>, class MappedContainer = std::vector<T>>

template<class... Args>

JPL_INLINE std::pair< iterator, bool > JPL::FlatMap< Key, T, Equals, KeyContainer, MappedContainer >::emplace ( Args &&... args )

inline

◆ empty()

template<class Key , class T , class Equals = std::equal_to<Key>, class KeyContainer = std::vector<Key>, class MappedContainer = std::vector<T>>

JPL_INLINE bool JPL::FlatMap< Key, T, Equals, KeyContainer, MappedContainer >::empty ( ) const

inline

◆ end() [1/2]

template<class Key , class T , class Equals = std::equal_to<Key>, class KeyContainer = std::vector<Key>, class MappedContainer = std::vector<T>>

JPL_INLINE const_iterator JPL::FlatMap< Key, T, Equals, KeyContainer, MappedContainer >::end ( ) const

inlinenoexcept

◆ end() [2/2]

template<class Key , class T , class Equals = std::equal_to<Key>, class KeyContainer = std::vector<Key>, class MappedContainer = std::vector<T>>

JPL_INLINE iterator JPL::FlatMap< Key, T, Equals, KeyContainer, MappedContainer >::end ( )

inlinenoexcept

◆ erase() [1/4]

template<class Key , class T , class Equals = std::equal_to<Key>, class KeyContainer = std::vector<Key>, class MappedContainer = std::vector<T>>

template<class K2 >
requires (EqComparable<Key, K2> || EqComparable<K2, Key>)

JPL_INLINE size_t JPL::FlatMap< Key, T, Equals, KeyContainer, MappedContainer >::erase ( const K2 & key_like )

inline

◆ erase() [2/4]

template<class Key , class T , class Equals = std::equal_to<Key>, class KeyContainer = std::vector<Key>, class MappedContainer = std::vector<T>>

JPL_INLINE size_t JPL::FlatMap< Key, T, Equals, KeyContainer, MappedContainer >::erase ( const Key & key )

inline

◆ erase() [3/4]

template<class Key , class T , class Equals = std::equal_to<Key>, class KeyContainer = std::vector<Key>, class MappedContainer = std::vector<T>>

JPL_INLINE size_t JPL::FlatMap< Key, T, Equals, KeyContainer, MappedContainer >::erase ( const_iterator iter )

inline

◆ erase() [4/4]

template<class Key , class T , class Equals = std::equal_to<Key>, class KeyContainer = std::vector<Key>, class MappedContainer = std::vector<T>>

JPL_INLINE size_t JPL::FlatMap< Key, T, Equals, KeyContainer, MappedContainer >::erase ( iterator it )

inline

◆ erase_if()

template<class Key , class T , class Equals = std::equal_to<Key>, class KeyContainer = std::vector<Key>, class MappedContainer = std::vector<T>>

template<class Predicate >

JPL_INLINE size_t JPL::FlatMap< Key, T, Equals, KeyContainer, MappedContainer >::erase_if ( Predicate && pred )

inline

◆ find() [1/4]

template<class Key , class T , class Equals = std::equal_to<Key>, class KeyContainer = std::vector<Key>, class MappedContainer = std::vector<T>>

template<class K2 >
requires (EqComparable<Key, K2> || EqComparable<K2, Key>)

JPL_INLINE iterator JPL::FlatMap< Key, T, Equals, KeyContainer, MappedContainer >::find ( const K2 & key_like )

inline

◆ find() [2/4]

template<class Key , class T , class Equals = std::equal_to<Key>, class KeyContainer = std::vector<Key>, class MappedContainer = std::vector<T>>

template<class K2 >
requires (EqComparable<Key, K2> || EqComparable<K2, Key>)

JPL_INLINE const_iterator JPL::FlatMap< Key, T, Equals, KeyContainer, MappedContainer >::find ( const K2 & key_like ) const

inline

◆ find() [3/4]

template<class Key , class T , class Equals = std::equal_to<Key>, class KeyContainer = std::vector<Key>, class MappedContainer = std::vector<T>>

JPL_INLINE iterator JPL::FlatMap< Key, T, Equals, KeyContainer, MappedContainer >::find ( const Key & key )

inline

◆ find() [4/4]

template<class Key , class T , class Equals = std::equal_to<Key>, class KeyContainer = std::vector<Key>, class MappedContainer = std::vector<T>>

JPL_INLINE const_iterator JPL::FlatMap< Key, T, Equals, KeyContainer, MappedContainer >::find ( const Key & key ) const

inline

◆ keys()

template<class Key , class T , class Equals = std::equal_to<Key>, class KeyContainer = std::vector<Key>, class MappedContainer = std::vector<T>>

JPL_INLINE const key_container_type & JPL::FlatMap< Key, T, Equals, KeyContainer, MappedContainer >::keys ( ) const

inlinenoexcept

◆ operator=() [1/2]

template<class Key , class T , class Equals = std::equal_to<Key>, class KeyContainer = std::vector<Key>, class MappedContainer = std::vector<T>>

FlatMap & JPL::FlatMap< Key, T, Equals, KeyContainer, MappedContainer >::operator= ( const FlatMap< Key, T, Equals, KeyContainer, MappedContainer > & )

default

◆ operator=() [2/2]

template<class Key , class T , class Equals = std::equal_to<Key>, class KeyContainer = std::vector<Key>, class MappedContainer = std::vector<T>>

FlatMap & JPL::FlatMap< Key, T, Equals, KeyContainer, MappedContainer >::operator= ( FlatMap< Key, T, Equals, KeyContainer, MappedContainer > && )

defaultnoexcept

◆ operator[]() [1/2]

template<class Key , class T , class Equals = std::equal_to<Key>, class KeyContainer = std::vector<Key>, class MappedContainer = std::vector<T>>

JPL_INLINE mapped_type & JPL::FlatMap< Key, T, Equals, KeyContainer, MappedContainer >::operator[] ( const Key & key )

inline

◆ operator[]() [2/2]

template<class Key , class T , class Equals = std::equal_to<Key>, class KeyContainer = std::vector<Key>, class MappedContainer = std::vector<T>>

JPL_INLINE mapped_type & JPL::FlatMap< Key, T, Equals, KeyContainer, MappedContainer >::operator[] ( Key && key )

inline

◆ push_back()

template<class Key , class T , class Equals = std::equal_to<Key>, class KeyContainer = std::vector<Key>, class MappedContainer = std::vector<T>>

JPL_INLINE void JPL::FlatMap< Key, T, Equals, KeyContainer, MappedContainer >::push_back	(	const Key &	k,
		const T &	v
	)

inline

◆ reserve()

template<class Key , class T , class Equals = std::equal_to<Key>, class KeyContainer = std::vector<Key>, class MappedContainer = std::vector<T>>

JPL_INLINE void JPL::FlatMap< Key, T, Equals, KeyContainer, MappedContainer >::reserve ( std::size_t n )

inline

◆ size()

template<class Key , class T , class Equals = std::equal_to<Key>, class KeyContainer = std::vector<Key>, class MappedContainer = std::vector<T>>

JPL_INLINE size_type JPL::FlatMap< Key, T, Equals, KeyContainer, MappedContainer >::size ( ) const

inline

◆ values()

template<class Key , class T , class Equals = std::equal_to<Key>, class KeyContainer = std::vector<Key>, class MappedContainer = std::vector<T>>

JPL_INLINE const mapped_container_type & JPL::FlatMap< Key, T, Equals, KeyContainer, MappedContainer >::values ( ) const

inlinenoexcept

Friends And Related Symbol Documentation

◆ swap

template<class Key , class T , class Equals = std::equal_to<Key>, class KeyContainer = std::vector<Key>, class MappedContainer = std::vector<T>>

void swap	(	FlatMap< Key, T, Equals, KeyContainer, MappedContainer > &	a,
		FlatMap< Key, T, Equals, KeyContainer, MappedContainer > &	b
	)

friend

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

JPLSpatial/Containers/FlatMap.h

Public Types

Public Member Functions

Friends

Member Typedef Documentation

◆ allocator_type

◆ const_iterator

◆ const_reference

◆ difference_type

◆ iterator

◆ key_compare

◆ key_container_type

◆ key_type

◆ mapped_container_type

◆ mapped_type

◆ reference

◆ size_type

◆ value_type

Constructor & Destructor Documentation

◆ FlatMap() [1/7]

◆ FlatMap() [2/7]

◆ ~FlatMap()

◆ FlatMap() [3/7]

◆ FlatMap() [4/7]

◆ FlatMap() [5/7]

◆ FlatMap() [6/7]

◆ FlatMap() [7/7]

Member Function Documentation

◆ at() [1/2]

◆ at() [2/2]

◆ begin() [1/2]

◆ begin() [2/2]

◆ cbegin()

◆ cend()

◆ contains() [1/2]

◆ contains() [2/2]

◆ emplace()

◆ empty()

◆ end() [1/2]

◆ end() [2/2]

◆ erase() [1/4]

◆ erase() [2/4]

◆ erase() [3/4]

◆ erase() [4/4]

◆ erase_if()

◆ find() [1/4]

◆ find() [2/4]

◆ find() [3/4]

◆ find() [4/4]

◆ keys()

◆ operator=() [1/2]

◆ operator=() [2/2]

◆ operator[]() [1/2]

◆ operator[]() [2/2]

◆ push_back()

◆ reserve()

◆ size()

◆ values()

Friends And Related Symbol Documentation

◆ swap