galois::flat_map< _Key, _Tp, _Compare, _Alloc, _Store > Class Template Reference

Simple map data structure, based off a single array. More...

#include <FlatMap.h>

Classes
class	value_compare

Public Types
typedef _Key	key_type
typedef _Tp	mapped_type
typedef std::pair< _Key, _Tp >	value_type
typedef _Compare	key_compare
typedef _Alloc	allocator_type
typedef _Pair_alloc_type::pointer	pointer
typedef _Pair_alloc_type::const_pointer	const_pointer
typedef _Pair_alloc_type::reference	reference
typedef _Pair_alloc_type::const_reference	const_reference
typedef _VectTy::iterator	iterator
typedef _VectTy::const_iterator	const_iterator
typedef _VectTy::size_type	size_type
typedef _VectTy::difference_type	difference_type
typedef _VectTy::reverse_iterator	reverse_iterator
typedef _VectTy::const_reverse_iterator	const_reverse_iterator

Public Member Functions
	flat_map ()
	flat_map (const _Compare &__comp, const allocator_type &=allocator_type())
	flat_map (const flat_map &__x)
	_comp (std::move(__x._comp))
template<typename _InputIterator >
	flat_map (_InputIterator __first, _InputIterator __last)
template<typename _InputIterator >
	flat_map (_InputIterator __first, _InputIterator __last, const _Compare &, const allocator_type &__a=allocator_type())
flat_map &	operator= (const flat_map &__x)
flat_map &	operator= (flat_map &&__x)
allocator_type	get_allocator () const
iterator	begin ()
const_iterator	begin () const
iterator	end ()
const_iterator	end () const
reverse_iterator	rbegin ()
const_reverse_iterator	rbegin () const
reverse_iterator	rend ()
const_reverse_iterator	rend () const
const_iterator	cbegin () const
const_iterator	cend () const
const_reverse_iterator	crbegin () const
const_reverse_iterator	crend () const
bool	empty () const
size_type	size () const
size_type	max_size () const
template<typename... Args>
std::pair< iterator, bool >	emplace (Args &&...args)
mapped_type &	operator[] (const key_type &__k)
mapped_type &	operator[] (key_type &&__k)
mapped_type &	at (const key_type &__k)
const mapped_type &	at (const key_type &__k) const
template<typename PairTy , typename = typename std::enable_if< std::is_constructible<value_type, PairTy&&>::value>::type>
std::pair< iterator, bool >	insert (PairTy &&__x)
template<typename _InputIterator >
void	insert (_InputIterator __first, _InputIterator __last)
iterator	erase (const_iterator __position)
iterator	erase (iterator __position)
size_type	erase (const key_type &__x)
iterator	erase (const_iterator __first, const_iterator __last)
void	swap (flat_map &__x)
void	clear ()
key_compare	key_comp () const
value_compare	value_comp () const
iterator	find (const key_type &__x)
const_iterator	find (const key_type &__x) const
size_type	count (const key_type &__x) const
iterator	lower_bound (const key_type &__x)
const_iterator	lower_bound (const key_type &__x) const
iterator	upper_bound (const key_type &__x)
const_iterator	upper_bound (const key_type &__x) const
std::pair< iterator, iterator >	equal_range (const key_type &__x)
std::pair< const_iterator, const_iterator >	equal_range (const key_type &__x) const

Public Attributes
	__pad0__: _data(std::move(__x._data))

Detailed Description

template<class _Key, class _Tp, class _Compare = std::less<_Key>, class _Alloc = std::allocator<std::pair<_Key, _Tp>>, class _Store = std::vector<std::pair<_Key, _Tp>, _Alloc>>
class galois::flat_map< _Key, _Tp, _Compare, _Alloc, _Store >

Simple map data structure, based off a single array.

Member Typedef Documentation

template<class _Key, class _Tp, class _Compare = std::less<_Key>, class _Alloc = std::allocator<std::pair<_Key, _Tp>>, class _Store = std::vector<std::pair<_Key, _Tp>, _Alloc>>

typedef _Alloc galois::flat_map< _Key, _Tp, _Compare, _Alloc, _Store >::allocator_type

template<class _Key, class _Tp, class _Compare = std::less<_Key>, class _Alloc = std::allocator<std::pair<_Key, _Tp>>, class _Store = std::vector<std::pair<_Key, _Tp>, _Alloc>>

typedef _VectTy::const_iterator galois::flat_map< _Key, _Tp, _Compare, _Alloc, _Store >::const_iterator

template<class _Key, class _Tp, class _Compare = std::less<_Key>, class _Alloc = std::allocator<std::pair<_Key, _Tp>>, class _Store = std::vector<std::pair<_Key, _Tp>, _Alloc>>

typedef _Pair_alloc_type::const_pointer galois::flat_map< _Key, _Tp, _Compare, _Alloc, _Store >::const_pointer

template<class _Key, class _Tp, class _Compare = std::less<_Key>, class _Alloc = std::allocator<std::pair<_Key, _Tp>>, class _Store = std::vector<std::pair<_Key, _Tp>, _Alloc>>

typedef _Pair_alloc_type::const_reference galois::flat_map< _Key, _Tp, _Compare, _Alloc, _Store >::const_reference

template<class _Key, class _Tp, class _Compare = std::less<_Key>, class _Alloc = std::allocator<std::pair<_Key, _Tp>>, class _Store = std::vector<std::pair<_Key, _Tp>, _Alloc>>

typedef _VectTy::const_reverse_iterator galois::flat_map< _Key, _Tp, _Compare, _Alloc, _Store >::const_reverse_iterator

template<class _Key, class _Tp, class _Compare = std::less<_Key>, class _Alloc = std::allocator<std::pair<_Key, _Tp>>, class _Store = std::vector<std::pair<_Key, _Tp>, _Alloc>>

typedef _VectTy::difference_type galois::flat_map< _Key, _Tp, _Compare, _Alloc, _Store >::difference_type

template<class _Key, class _Tp, class _Compare = std::less<_Key>, class _Alloc = std::allocator<std::pair<_Key, _Tp>>, class _Store = std::vector<std::pair<_Key, _Tp>, _Alloc>>

typedef _VectTy::iterator galois::flat_map< _Key, _Tp, _Compare, _Alloc, _Store >::iterator

template<class _Key, class _Tp, class _Compare = std::less<_Key>, class _Alloc = std::allocator<std::pair<_Key, _Tp>>, class _Store = std::vector<std::pair<_Key, _Tp>, _Alloc>>

typedef _Compare galois::flat_map< _Key, _Tp, _Compare, _Alloc, _Store >::key_compare

template<class _Key, class _Tp, class _Compare = std::less<_Key>, class _Alloc = std::allocator<std::pair<_Key, _Tp>>, class _Store = std::vector<std::pair<_Key, _Tp>, _Alloc>>

typedef _Key galois::flat_map< _Key, _Tp, _Compare, _Alloc, _Store >::key_type

template<class _Key, class _Tp, class _Compare = std::less<_Key>, class _Alloc = std::allocator<std::pair<_Key, _Tp>>, class _Store = std::vector<std::pair<_Key, _Tp>, _Alloc>>

typedef _Tp galois::flat_map< _Key, _Tp, _Compare, _Alloc, _Store >::mapped_type

template<class _Key, class _Tp, class _Compare = std::less<_Key>, class _Alloc = std::allocator<std::pair<_Key, _Tp>>, class _Store = std::vector<std::pair<_Key, _Tp>, _Alloc>>

typedef _Pair_alloc_type::pointer galois::flat_map< _Key, _Tp, _Compare, _Alloc, _Store >::pointer

template<class _Key, class _Tp, class _Compare = std::less<_Key>, class _Alloc = std::allocator<std::pair<_Key, _Tp>>, class _Store = std::vector<std::pair<_Key, _Tp>, _Alloc>>

typedef _Pair_alloc_type::reference galois::flat_map< _Key, _Tp, _Compare, _Alloc, _Store >::reference

template<class _Key, class _Tp, class _Compare = std::less<_Key>, class _Alloc = std::allocator<std::pair<_Key, _Tp>>, class _Store = std::vector<std::pair<_Key, _Tp>, _Alloc>>

typedef _VectTy::reverse_iterator galois::flat_map< _Key, _Tp, _Compare, _Alloc, _Store >::reverse_iterator

template<class _Key, class _Tp, class _Compare = std::less<_Key>, class _Alloc = std::allocator<std::pair<_Key, _Tp>>, class _Store = std::vector<std::pair<_Key, _Tp>, _Alloc>>

typedef _VectTy::size_type galois::flat_map< _Key, _Tp, _Compare, _Alloc, _Store >::size_type

template<class _Key, class _Tp, class _Compare = std::less<_Key>, class _Alloc = std::allocator<std::pair<_Key, _Tp>>, class _Store = std::vector<std::pair<_Key, _Tp>, _Alloc>>

typedef std::pair<_Key, _Tp> galois::flat_map< _Key, _Tp, _Compare, _Alloc, _Store >::value_type

Constructor & Destructor Documentation

template<class _Key, class _Tp, class _Compare = std::less<_Key>, class _Alloc = std::allocator<std::pair<_Key, _Tp>>, class _Store = std::vector<std::pair<_Key, _Tp>, _Alloc>>

galois::flat_map< _Key, _Tp, _Compare, _Alloc, _Store >::flat_map ( )

inline

template<class _Key, class _Tp, class _Compare = std::less<_Key>, class _Alloc = std::allocator<std::pair<_Key, _Tp>>, class _Store = std::vector<std::pair<_Key, _Tp>, _Alloc>>

galois::flat_map< _Key, _Tp, _Compare, _Alloc, _Store >::flat_map ( const _Compare &  __comp, const allocator_type &  = allocator_type()  )

inlineexplicit

template<class _Key, class _Tp, class _Compare = std::less<_Key>, class _Alloc = std::allocator<std::pair<_Key, _Tp>>, class _Store = std::vector<std::pair<_Key, _Tp>, _Alloc>>

galois::flat_map< _Key, _Tp, _Compare, _Alloc, _Store >::flat_map ( const flat_map< _Key, _Tp, _Compare, _Alloc, _Store > &  __x )

inline

template<class _Key, class _Tp, class _Compare = std::less<_Key>, class _Alloc = std::allocator<std::pair<_Key, _Tp>>, class _Store = std::vector<std::pair<_Key, _Tp>, _Alloc>>

template<typename _InputIterator >

galois::flat_map< _Key, _Tp, _Compare, _Alloc, _Store >::flat_map ( _InputIterator  __first, _InputIterator  __last  )

inline

template<class _Key, class _Tp, class _Compare = std::less<_Key>, class _Alloc = std::allocator<std::pair<_Key, _Tp>>, class _Store = std::vector<std::pair<_Key, _Tp>, _Alloc>>

template<typename _InputIterator >

galois::flat_map< _Key, _Tp, _Compare, _Alloc, _Store >::flat_map ( _InputIterator  __first, _InputIterator  __last, const _Compare &  , const allocator_type &  __a = allocator_type()  )

inline

Member Function Documentation

template<class _Key, class _Tp, class _Compare = std::less<_Key>, class _Alloc = std::allocator<std::pair<_Key, _Tp>>, class _Store = std::vector<std::pair<_Key, _Tp>, _Alloc>>

galois::flat_map< _Key, _Tp, _Compare, _Alloc, _Store >::_comp ( std::  move__x._comp )

inline

template<class _Key, class _Tp, class _Compare = std::less<_Key>, class _Alloc = std::allocator<std::pair<_Key, _Tp>>, class _Store = std::vector<std::pair<_Key, _Tp>, _Alloc>>

mapped_type& galois::flat_map< _Key, _Tp, _Compare, _Alloc, _Store >::at ( const key_type &  __k )

inline

template<class _Key, class _Tp, class _Compare = std::less<_Key>, class _Alloc = std::allocator<std::pair<_Key, _Tp>>, class _Store = std::vector<std::pair<_Key, _Tp>, _Alloc>>

const mapped_type& galois::flat_map< _Key, _Tp, _Compare, _Alloc, _Store >::at ( const key_type &  __k ) const

inline

template<class _Key, class _Tp, class _Compare = std::less<_Key>, class _Alloc = std::allocator<std::pair<_Key, _Tp>>, class _Store = std::vector<std::pair<_Key, _Tp>, _Alloc>>

iterator galois::flat_map< _Key, _Tp, _Compare, _Alloc, _Store >::begin ( )

inline

template<class _Key, class _Tp, class _Compare = std::less<_Key>, class _Alloc = std::allocator<std::pair<_Key, _Tp>>, class _Store = std::vector<std::pair<_Key, _Tp>, _Alloc>>

const_iterator galois::flat_map< _Key, _Tp, _Compare, _Alloc, _Store >::begin ( ) const

inline

template<class _Key, class _Tp, class _Compare = std::less<_Key>, class _Alloc = std::allocator<std::pair<_Key, _Tp>>, class _Store = std::vector<std::pair<_Key, _Tp>, _Alloc>>

const_iterator galois::flat_map< _Key, _Tp, _Compare, _Alloc, _Store >::cbegin ( ) const

inline

template<class _Key, class _Tp, class _Compare = std::less<_Key>, class _Alloc = std::allocator<std::pair<_Key, _Tp>>, class _Store = std::vector<std::pair<_Key, _Tp>, _Alloc>>

const_iterator galois::flat_map< _Key, _Tp, _Compare, _Alloc, _Store >::cend ( ) const

inline

template<class _Key, class _Tp, class _Compare = std::less<_Key>, class _Alloc = std::allocator<std::pair<_Key, _Tp>>, class _Store = std::vector<std::pair<_Key, _Tp>, _Alloc>>

void galois::flat_map< _Key, _Tp, _Compare, _Alloc, _Store >::clear ( )

inline

template<class _Key, class _Tp, class _Compare = std::less<_Key>, class _Alloc = std::allocator<std::pair<_Key, _Tp>>, class _Store = std::vector<std::pair<_Key, _Tp>, _Alloc>>

size_type galois::flat_map< _Key, _Tp, _Compare, _Alloc, _Store >::count ( const key_type &  __x ) const

inline

template<class _Key, class _Tp, class _Compare = std::less<_Key>, class _Alloc = std::allocator<std::pair<_Key, _Tp>>, class _Store = std::vector<std::pair<_Key, _Tp>, _Alloc>>

const_reverse_iterator galois::flat_map< _Key, _Tp, _Compare, _Alloc, _Store >::crbegin ( ) const

inline

template<class _Key, class _Tp, class _Compare = std::less<_Key>, class _Alloc = std::allocator<std::pair<_Key, _Tp>>, class _Store = std::vector<std::pair<_Key, _Tp>, _Alloc>>

const_reverse_iterator galois::flat_map< _Key, _Tp, _Compare, _Alloc, _Store >::crend ( ) const

inline

template<class _Key, class _Tp, class _Compare = std::less<_Key>, class _Alloc = std::allocator<std::pair<_Key, _Tp>>, class _Store = std::vector<std::pair<_Key, _Tp>, _Alloc>>

template<typename... Args>

std::pair<iterator, bool> galois::flat_map< _Key, _Tp, _Compare, _Alloc, _Store >::emplace ( Args &&...  args )

inline

template<class _Key, class _Tp, class _Compare = std::less<_Key>, class _Alloc = std::allocator<std::pair<_Key, _Tp>>, class _Store = std::vector<std::pair<_Key, _Tp>, _Alloc>>

bool galois::flat_map< _Key, _Tp, _Compare, _Alloc, _Store >::empty ( ) const

inline

template<class _Key, class _Tp, class _Compare = std::less<_Key>, class _Alloc = std::allocator<std::pair<_Key, _Tp>>, class _Store = std::vector<std::pair<_Key, _Tp>, _Alloc>>

iterator galois::flat_map< _Key, _Tp, _Compare, _Alloc, _Store >::end ( )

inline

template<class _Key, class _Tp, class _Compare = std::less<_Key>, class _Alloc = std::allocator<std::pair<_Key, _Tp>>, class _Store = std::vector<std::pair<_Key, _Tp>, _Alloc>>

const_iterator galois::flat_map< _Key, _Tp, _Compare, _Alloc, _Store >::end ( ) const

inline

template<class _Key, class _Tp, class _Compare = std::less<_Key>, class _Alloc = std::allocator<std::pair<_Key, _Tp>>, class _Store = std::vector<std::pair<_Key, _Tp>, _Alloc>>

std::pair<iterator, iterator> galois::flat_map< _Key, _Tp, _Compare, _Alloc, _Store >::equal_range ( const key_type &  __x )

inline

template<class _Key, class _Tp, class _Compare = std::less<_Key>, class _Alloc = std::allocator<std::pair<_Key, _Tp>>, class _Store = std::vector<std::pair<_Key, _Tp>, _Alloc>>

std::pair<const_iterator, const_iterator> galois::flat_map< _Key, _Tp, _Compare, _Alloc, _Store >::equal_range ( const key_type &  __x ) const

inline

template<class _Key, class _Tp, class _Compare = std::less<_Key>, class _Alloc = std::allocator<std::pair<_Key, _Tp>>, class _Store = std::vector<std::pair<_Key, _Tp>, _Alloc>>

iterator galois::flat_map< _Key, _Tp, _Compare, _Alloc, _Store >::erase ( const_iterator  __position )

inline

template<class _Key, class _Tp, class _Compare = std::less<_Key>, class _Alloc = std::allocator<std::pair<_Key, _Tp>>, class _Store = std::vector<std::pair<_Key, _Tp>, _Alloc>>

iterator galois::flat_map< _Key, _Tp, _Compare, _Alloc, _Store >::erase ( iterator  __position )

inline

template<class _Key, class _Tp, class _Compare = std::less<_Key>, class _Alloc = std::allocator<std::pair<_Key, _Tp>>, class _Store = std::vector<std::pair<_Key, _Tp>, _Alloc>>

size_type galois::flat_map< _Key, _Tp, _Compare, _Alloc, _Store >::erase ( const key_type &  __x )

inline

template<class _Key, class _Tp, class _Compare = std::less<_Key>, class _Alloc = std::allocator<std::pair<_Key, _Tp>>, class _Store = std::vector<std::pair<_Key, _Tp>, _Alloc>>

iterator galois::flat_map< _Key, _Tp, _Compare, _Alloc, _Store >::erase ( const_iterator  __first, const_iterator  __last  )

inline

template<class _Key, class _Tp, class _Compare = std::less<_Key>, class _Alloc = std::allocator<std::pair<_Key, _Tp>>, class _Store = std::vector<std::pair<_Key, _Tp>, _Alloc>>

iterator galois::flat_map< _Key, _Tp, _Compare, _Alloc, _Store >::find ( const key_type &  __x )

inline

template<class _Key, class _Tp, class _Compare = std::less<_Key>, class _Alloc = std::allocator<std::pair<_Key, _Tp>>, class _Store = std::vector<std::pair<_Key, _Tp>, _Alloc>>

const_iterator galois::flat_map< _Key, _Tp, _Compare, _Alloc, _Store >::find ( const key_type &  __x ) const

inline

template<class _Key, class _Tp, class _Compare = std::less<_Key>, class _Alloc = std::allocator<std::pair<_Key, _Tp>>, class _Store = std::vector<std::pair<_Key, _Tp>, _Alloc>>

allocator_type galois::flat_map< _Key, _Tp, _Compare, _Alloc, _Store >::get_allocator ( ) const

inline

template<class _Key, class _Tp, class _Compare = std::less<_Key>, class _Alloc = std::allocator<std::pair<_Key, _Tp>>, class _Store = std::vector<std::pair<_Key, _Tp>, _Alloc>>

template<typename PairTy , typename = typename std::enable_if< std::is_constructible<value_type, PairTy&&>::value>::type>

std::pair<iterator, bool> galois::flat_map< _Key, _Tp, _Compare, _Alloc, _Store >::insert ( PairTy &&  __x )

inline

template<class _Key, class _Tp, class _Compare = std::less<_Key>, class _Alloc = std::allocator<std::pair<_Key, _Tp>>, class _Store = std::vector<std::pair<_Key, _Tp>, _Alloc>>

template<typename _InputIterator >

void galois::flat_map< _Key, _Tp, _Compare, _Alloc, _Store >::insert ( _InputIterator  __first, _InputIterator  __last  )

inline

template<class _Key, class _Tp, class _Compare = std::less<_Key>, class _Alloc = std::allocator<std::pair<_Key, _Tp>>, class _Store = std::vector<std::pair<_Key, _Tp>, _Alloc>>

key_compare galois::flat_map< _Key, _Tp, _Compare, _Alloc, _Store >::key_comp ( ) const

inline

template<class _Key, class _Tp, class _Compare = std::less<_Key>, class _Alloc = std::allocator<std::pair<_Key, _Tp>>, class _Store = std::vector<std::pair<_Key, _Tp>, _Alloc>>

iterator galois::flat_map< _Key, _Tp, _Compare, _Alloc, _Store >::lower_bound ( const key_type &  __x )

inline

template<class _Key, class _Tp, class _Compare = std::less<_Key>, class _Alloc = std::allocator<std::pair<_Key, _Tp>>, class _Store = std::vector<std::pair<_Key, _Tp>, _Alloc>>

const_iterator galois::flat_map< _Key, _Tp, _Compare, _Alloc, _Store >::lower_bound ( const key_type &  __x ) const

inline

template<class _Key, class _Tp, class _Compare = std::less<_Key>, class _Alloc = std::allocator<std::pair<_Key, _Tp>>, class _Store = std::vector<std::pair<_Key, _Tp>, _Alloc>>

size_type galois::flat_map< _Key, _Tp, _Compare, _Alloc, _Store >::max_size ( ) const

inline

template<class _Key, class _Tp, class _Compare = std::less<_Key>, class _Alloc = std::allocator<std::pair<_Key, _Tp>>, class _Store = std::vector<std::pair<_Key, _Tp>, _Alloc>>

flat_map& galois::flat_map< _Key, _Tp, _Compare, _Alloc, _Store >::operator= ( const flat_map< _Key, _Tp, _Compare, _Alloc, _Store > &  __x )

inline

template<class _Key, class _Tp, class _Compare = std::less<_Key>, class _Alloc = std::allocator<std::pair<_Key, _Tp>>, class _Store = std::vector<std::pair<_Key, _Tp>, _Alloc>>

flat_map& galois::flat_map< _Key, _Tp, _Compare, _Alloc, _Store >::operator= ( flat_map< _Key, _Tp, _Compare, _Alloc, _Store > &&  __x )

inline

template<class _Key, class _Tp, class _Compare = std::less<_Key>, class _Alloc = std::allocator<std::pair<_Key, _Tp>>, class _Store = std::vector<std::pair<_Key, _Tp>, _Alloc>>

mapped_type& galois::flat_map< _Key, _Tp, _Compare, _Alloc, _Store >::operator[] ( const key_type &  __k )

inline

template<class _Key, class _Tp, class _Compare = std::less<_Key>, class _Alloc = std::allocator<std::pair<_Key, _Tp>>, class _Store = std::vector<std::pair<_Key, _Tp>, _Alloc>>

mapped_type& galois::flat_map< _Key, _Tp, _Compare, _Alloc, _Store >::operator[] ( key_type &&  __k )

inline

template<class _Key, class _Tp, class _Compare = std::less<_Key>, class _Alloc = std::allocator<std::pair<_Key, _Tp>>, class _Store = std::vector<std::pair<_Key, _Tp>, _Alloc>>

reverse_iterator galois::flat_map< _Key, _Tp, _Compare, _Alloc, _Store >::rbegin ( )

inline

template<class _Key, class _Tp, class _Compare = std::less<_Key>, class _Alloc = std::allocator<std::pair<_Key, _Tp>>, class _Store = std::vector<std::pair<_Key, _Tp>, _Alloc>>

const_reverse_iterator galois::flat_map< _Key, _Tp, _Compare, _Alloc, _Store >::rbegin ( ) const

inline

template<class _Key, class _Tp, class _Compare = std::less<_Key>, class _Alloc = std::allocator<std::pair<_Key, _Tp>>, class _Store = std::vector<std::pair<_Key, _Tp>, _Alloc>>

reverse_iterator galois::flat_map< _Key, _Tp, _Compare, _Alloc, _Store >::rend ( )

inline

template<class _Key, class _Tp, class _Compare = std::less<_Key>, class _Alloc = std::allocator<std::pair<_Key, _Tp>>, class _Store = std::vector<std::pair<_Key, _Tp>, _Alloc>>

const_reverse_iterator galois::flat_map< _Key, _Tp, _Compare, _Alloc, _Store >::rend ( ) const

inline

template<class _Key, class _Tp, class _Compare = std::less<_Key>, class _Alloc = std::allocator<std::pair<_Key, _Tp>>, class _Store = std::vector<std::pair<_Key, _Tp>, _Alloc>>

size_type galois::flat_map< _Key, _Tp, _Compare, _Alloc, _Store >::size ( ) const

inline

template<class _Key, class _Tp, class _Compare = std::less<_Key>, class _Alloc = std::allocator<std::pair<_Key, _Tp>>, class _Store = std::vector<std::pair<_Key, _Tp>, _Alloc>>

void galois::flat_map< _Key, _Tp, _Compare, _Alloc, _Store >::swap ( flat_map< _Key, _Tp, _Compare, _Alloc, _Store > &  __x )

inline

template<class _Key, class _Tp, class _Compare = std::less<_Key>, class _Alloc = std::allocator<std::pair<_Key, _Tp>>, class _Store = std::vector<std::pair<_Key, _Tp>, _Alloc>>

iterator galois::flat_map< _Key, _Tp, _Compare, _Alloc, _Store >::upper_bound ( const key_type &  __x )

inline

template<class _Key, class _Tp, class _Compare = std::less<_Key>, class _Alloc = std::allocator<std::pair<_Key, _Tp>>, class _Store = std::vector<std::pair<_Key, _Tp>, _Alloc>>

const_iterator galois::flat_map< _Key, _Tp, _Compare, _Alloc, _Store >::upper_bound ( const key_type &  __x ) const

inline

template<class _Key, class _Tp, class _Compare = std::less<_Key>, class _Alloc = std::allocator<std::pair<_Key, _Tp>>, class _Store = std::vector<std::pair<_Key, _Tp>, _Alloc>>

value_compare galois::flat_map< _Key, _Tp, _Compare, _Alloc, _Store >::value_comp ( ) const

inline

Member Data Documentation

template<class _Key, class _Tp, class _Compare = std::less<_Key>, class _Alloc = std::allocator<std::pair<_Key, _Tp>>, class _Store = std::vector<std::pair<_Key, _Tp>, _Alloc>>

galois::flat_map< _Key, _Tp, _Compare, _Alloc, _Store >::__pad0__

---

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

• FlatMap.h