JPL::FlatMap< Key, T, Equals, KeyContainer, MappedContainer > Class Template Reference

#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 )

inlinenodiscard

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

inlinenodiscard

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

inlinenodiscardnoexcept

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 ( )

inlinenodiscardnoexcept

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

inlinenodiscardnoexcept

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

inlinenodiscardnoexcept

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

inlinenodiscard

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

inlinenodiscard

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

inlinenodiscard

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

inlinenodiscardnoexcept

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 ( )

inlinenodiscardnoexcept

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 )

inlinenodiscard

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

inlinenodiscard

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 )

inlinenodiscard

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

inlinenodiscard

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

inlinenodiscardnoexcept

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 )

inlinenodiscard

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 )

inlinenodiscard

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

inlinenodiscard

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

inlinenodiscardnoexcept

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