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

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

#include <FlatMap.h>

List of all members.

Classes
class	value_compare
class	value_key_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 &__a=allocator_type())
	flat_map (const flat_map &__x)
	flat_map (flat_map &&__x)
template<typename _InputIterator >
	flat_map (_InputIterator __first, _InputIterator __last)
template<typename _InputIterator >
	flat_map (_InputIterator __first, _InputIterator __last, const _Compare &__comp, 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
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
std::pair< iterator, bool >	insert (const value_type &__x)
template<typename _Pair >
std::pair< iterator, bool >	insert (_Pair &&__x)
iterator	insert (const_iterator __position, const value_type &__x)
template<typename _Pair >
iterator	insert (const_iterator __position, _Pair &&__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
Private Types
typedef _Alloc::template rebind< value_type >::other	_Pair_alloc_type
	This turns...
typedef std::vector < value_type, _Pair_alloc_type >	_VectTy
Private Member Functions
value_key_compare	value_key_comp () const
bool	key_eq (const key_type &k1, const key_type &k2) const
void	resort ()
Private Attributes
_VectTy	_data
_Compare	_comp
Friends
template<typename _K1 , typename _T1 , typename _C1 , typename _A1 >
bool	operator== (const flat_map< _K1, _T1, _C1, _A1 > &, const flat_map< _K1, _T1, _C1, _A1 > &)
template<typename _K1 , typename _T1 , typename _C1 , typename _A1 >
bool	operator< (const flat_map< _K1, _T1, _C1, _A1 > &, const flat_map< _K1, _T1, _C1, _A1 > &)

---

Detailed Description

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

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

typedef _Alloc::template rebind<value_type>::other Galois::flat_map< _Key, _Tp, _Compare, _Alloc >::_Pair_alloc_type [private]

This turns...

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

typedef std::vector<value_type, _Pair_alloc_type> Galois::flat_map< _Key, _Tp, _Compare, _Alloc >::_VectTy [private]

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

typedef _Alloc Galois::flat_map< _Key, _Tp, _Compare, _Alloc >::allocator_type

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

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

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

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

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

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

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

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

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

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

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

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

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

typedef _Compare Galois::flat_map< _Key, _Tp, _Compare, _Alloc >::key_compare

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

typedef _Key Galois::flat_map< _Key, _Tp, _Compare, _Alloc >::key_type

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

typedef _Tp Galois::flat_map< _Key, _Tp, _Compare, _Alloc >::mapped_type

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

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

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

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

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

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

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

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

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

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

---

Constructor & Destructor Documentation

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

Galois::flat_map< _Key, _Tp, _Compare, _Alloc >::flat_map

(

)

[inline]

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

Galois::flat_map< _Key, _Tp, _Compare, _Alloc >::flat_map	(	const _Compare &	__comp,
		const allocator_type &	__a = allocator_type()
	)			[inline, explicit]

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

Galois::flat_map< _Key, _Tp, _Compare, _Alloc >::flat_map

(

const flat_map< _Key, _Tp, _Compare, _Alloc > &

__x

)

[inline]

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

Galois::flat_map< _Key, _Tp, _Compare, _Alloc >::flat_map

(

flat_map< _Key, _Tp, _Compare, _Alloc > &&

__x

)

[inline]

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

template<typename _InputIterator >

Galois::flat_map< _Key, _Tp, _Compare, _Alloc >::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> >>

template<typename _InputIterator >

Galois::flat_map< _Key, _Tp, _Compare, _Alloc >::flat_map	(	_InputIterator	__first,
		_InputIterator	__last,
		const _Compare &	__comp,
		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> >>

const mapped_type& Galois::flat_map< _Key, _Tp, _Compare, _Alloc >::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> >>

mapped_type& Galois::flat_map< _Key, _Tp, _Compare, _Alloc >::at

(

const key_type &

__k

)

[inline]

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

const_iterator Galois::flat_map< _Key, _Tp, _Compare, _Alloc >::begin

(

)

const [inline]

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

iterator Galois::flat_map< _Key, _Tp, _Compare, _Alloc >::begin

(

)

[inline]

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

const_iterator Galois::flat_map< _Key, _Tp, _Compare, _Alloc >::cbegin

(

)

const [inline]

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

const_iterator Galois::flat_map< _Key, _Tp, _Compare, _Alloc >::cend

(

)

const [inline]

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

void Galois::flat_map< _Key, _Tp, _Compare, _Alloc >::clear

(

)

[inline]

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

size_type Galois::flat_map< _Key, _Tp, _Compare, _Alloc >::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> >>

const_reverse_iterator Galois::flat_map< _Key, _Tp, _Compare, _Alloc >::crbegin

(

)

const [inline]

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

const_reverse_iterator Galois::flat_map< _Key, _Tp, _Compare, _Alloc >::crend

(

)

const [inline]

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

bool Galois::flat_map< _Key, _Tp, _Compare, _Alloc >::empty

(

)

const [inline]

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

const_iterator Galois::flat_map< _Key, _Tp, _Compare, _Alloc >::end

(

)

const [inline]

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

iterator Galois::flat_map< _Key, _Tp, _Compare, _Alloc >::end

(

)

[inline]

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

std::pair<const_iterator, const_iterator> Galois::flat_map< _Key, _Tp, _Compare, _Alloc >::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> >>

std::pair<iterator, iterator> Galois::flat_map< _Key, _Tp, _Compare, _Alloc >::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> >>

iterator Galois::flat_map< _Key, _Tp, _Compare, _Alloc >::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> >>

size_type Galois::flat_map< _Key, _Tp, _Compare, _Alloc >::erase

(

const key_type &

__x

)

[inline]

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

iterator Galois::flat_map< _Key, _Tp, _Compare, _Alloc >::erase

(

iterator

__position

)

[inline]

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

iterator Galois::flat_map< _Key, _Tp, _Compare, _Alloc >::erase

(

const_iterator

__position

)

[inline]

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

const_iterator Galois::flat_map< _Key, _Tp, _Compare, _Alloc >::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> >>

iterator Galois::flat_map< _Key, _Tp, _Compare, _Alloc >::find

(

const key_type &

__x

)

[inline]

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

allocator_type Galois::flat_map< _Key, _Tp, _Compare, _Alloc >::get_allocator

(

)

const [inline]

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

template<typename _InputIterator >

void Galois::flat_map< _Key, _Tp, _Compare, _Alloc >::insert	(	_InputIterator	__first,
		_InputIterator	__last
	)			[inline]

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

template<typename _Pair >

iterator Galois::flat_map< _Key, _Tp, _Compare, _Alloc >::insert	(	const_iterator	__position,
		_Pair &&	__x
	)			[inline]

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

iterator Galois::flat_map< _Key, _Tp, _Compare, _Alloc >::insert	(	const_iterator	__position,
		const value_type &	__x
	)			[inline]

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

template<typename _Pair >

std::pair<iterator, bool> Galois::flat_map< _Key, _Tp, _Compare, _Alloc >::insert

(

_Pair &&

__x

)

[inline]

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

std::pair<iterator, bool> Galois::flat_map< _Key, _Tp, _Compare, _Alloc >::insert

(

const value_type &

__x

)

[inline]

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

key_compare Galois::flat_map< _Key, _Tp, _Compare, _Alloc >::key_comp

(

)

const [inline]

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

bool Galois::flat_map< _Key, _Tp, _Compare, _Alloc >::key_eq	(	const key_type &	k1,
		const key_type &	k2
	)			const [inline, private]

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

const_iterator Galois::flat_map< _Key, _Tp, _Compare, _Alloc >::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> >>

iterator Galois::flat_map< _Key, _Tp, _Compare, _Alloc >::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> >>

size_type Galois::flat_map< _Key, _Tp, _Compare, _Alloc >::max_size

(

)

const [inline]

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

flat_map& Galois::flat_map< _Key, _Tp, _Compare, _Alloc >::operator=

(

flat_map< _Key, _Tp, _Compare, _Alloc > &&

__x

)

[inline]

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

flat_map& Galois::flat_map< _Key, _Tp, _Compare, _Alloc >::operator=

(

const flat_map< _Key, _Tp, _Compare, _Alloc > &

__x

)

[inline]

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

mapped_type& Galois::flat_map< _Key, _Tp, _Compare, _Alloc >::operator[]

(

key_type &&

__k

)

[inline]

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

mapped_type& Galois::flat_map< _Key, _Tp, _Compare, _Alloc >::operator[]

(

const key_type &

__k

)

[inline]

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

const_reverse_iterator Galois::flat_map< _Key, _Tp, _Compare, _Alloc >::rbegin

(

)

const [inline]

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

reverse_iterator Galois::flat_map< _Key, _Tp, _Compare, _Alloc >::rbegin

(

)

[inline]

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

const_reverse_iterator Galois::flat_map< _Key, _Tp, _Compare, _Alloc >::rend

(

)

const [inline]

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

reverse_iterator Galois::flat_map< _Key, _Tp, _Compare, _Alloc >::rend

(

)

[inline]

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

void Galois::flat_map< _Key, _Tp, _Compare, _Alloc >::resort

(

)

[inline, private]

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

size_type Galois::flat_map< _Key, _Tp, _Compare, _Alloc >::size

(

)

const [inline]

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

void Galois::flat_map< _Key, _Tp, _Compare, _Alloc >::swap

(

flat_map< _Key, _Tp, _Compare, _Alloc > &

__x

)

[inline]

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

const_iterator Galois::flat_map< _Key, _Tp, _Compare, _Alloc >::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> >>

iterator Galois::flat_map< _Key, _Tp, _Compare, _Alloc >::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> >>

value_compare Galois::flat_map< _Key, _Tp, _Compare, _Alloc >::value_comp

(

)

const [inline]

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

value_key_compare Galois::flat_map< _Key, _Tp, _Compare, _Alloc >::value_key_comp

(

)

const [inline, private]

---

Friends And Related Function Documentation

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

template<typename _K1 , typename _T1 , typename _C1 , typename _A1 >

bool operator<	(	const flat_map< _K1, _T1, _C1, _A1 > &	,
		const flat_map< _K1, _T1, _C1, _A1 > &
	)			[friend]

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

template<typename _K1 , typename _T1 , typename _C1 , typename _A1 >

bool operator==	(	const flat_map< _K1, _T1, _C1, _A1 > &	,
		const flat_map< _K1, _T1, _C1, _A1 > &
	)			[friend]

---

Member Data Documentation

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

_Compare Galois::flat_map< _Key, _Tp, _Compare, _Alloc >::_comp [private]

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

_VectTy Galois::flat_map< _Key, _Tp, _Compare, _Alloc >::_data [private]

---

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

• FlatMap.h