Loki::AssocVector< K, V, C, A > Class Template Reference

#include <lokiAssocVector.h>

Inheritance diagram for Loki::AssocVector< K, V, C, A >:

[legend]Collaboration diagram for Loki::AssocVector< K, V, C, A >:

[legend]List of all members.

Public Types
typedef K	key_type
typedef V	mapped_type
typedef Base::value_type	value_type
typedef C	key_compare
typedef A	allocator_type
typedef A::reference	reference
typedef A::const_reference	const_reference
typedef Base::iterator	iterator
typedef Base::const_iterator	const_iterator
typedef Base::size_type	size_type
typedef Base::difference_type	difference_type
typedef A::pointer	pointer
typedef A::const_pointer	const_pointer
typedef Base::reverse_iterator	reverse_iterator
typedef Base::const_reverse_iterator	const_reverse_iterator
Public Member Functions
	AssocVector (const key_compare &comp=key_compare(), const A &alloc=A())
template<class InputIterator>	AssocVector (InputIterator first, InputIterator last, const key_compare &comp=key_compare(), const A &alloc=A())
AssocVector &	operator= (const AssocVector &rhs)
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
bool	empty () const
size_type	size () const
size_type	max_size ()
mapped_type &	operator[] (const key_type &key)
std::pair< iterator, bool >	insert (const value_type &val)
iterator	insert (iterator pos, const value_type &val)
template<class InputIterator> void	insert (InputIterator first, InputIterator last)
void	erase (iterator pos)
size_type	erase (const key_type &k)
void	erase (iterator first, iterator last)
void	swap (AssocVector &other)
void	clear ()
key_compare	key_comp () const
value_compare	value_comp () const
iterator	find (const key_type &k)
const_iterator	find (const key_type &k) const
size_type	count (const key_type &k) const
iterator	lower_bound (const key_type &k)
const_iterator	lower_bound (const key_type &k) const
iterator	upper_bound (const key_type &k)
const_iterator	upper_bound (const key_type &k) const
std::pair< iterator, iterator >	equal_range (const key_type &k)
std::pair< const_iterator, const_iterator >	equal_range (const key_type &k) const
bool	operator< (const AssocVector &rhs) const
Private Types
typedef std::vector< std::pair< K, V >, A >	Base
typedef Private::AssocVectorCompare< V, C >	MyCompare
Friends
bool	operator== (const AssocVector &lhs, const AssocVector &rhs)
bool	operator!= (const AssocVector &lhs, const AssocVector &rhs)
bool	operator> (const AssocVector &lhs, const AssocVector &rhs)
bool	operator>= (const AssocVector &lhs, const AssocVector &rhs)
bool	operator<= (const AssocVector &lhs, const AssocVector &rhs)

template<class K, class V, class C = std::less<K>, class A = std::allocator< std::pair<K, V> >>
class Loki::AssocVector< K, V, C, A >

---

Member Typedef Documentation

template<class K, class V, class C = std::less<K>, class A = std::allocator< std::pair<K, V> >> typedef A Loki::AssocVector< K, V, C, A >::allocator_type

template<class K, class V, class C = std::less<K>, class A = std::allocator< std::pair<K, V> >> typedef std::vector<std::pair<K, V>, A> Loki::AssocVector< K, V, C, A >::Base [private]

template<class K, class V, class C = std::less<K>, class A = std::allocator< std::pair<K, V> >> typedef Base::const_iterator Loki::AssocVector< K, V, C, A >::const_iterator

template<class K, class V, class C = std::less<K>, class A = std::allocator< std::pair<K, V> >> typedef A::const_pointer Loki::AssocVector< K, V, C, A >::const_pointer

template<class K, class V, class C = std::less<K>, class A = std::allocator< std::pair<K, V> >> typedef A::const_reference Loki::AssocVector< K, V, C, A >::const_reference

template<class K, class V, class C = std::less<K>, class A = std::allocator< std::pair<K, V> >> typedef Base::const_reverse_iterator Loki::AssocVector< K, V, C, A >::const_reverse_iterator

template<class K, class V, class C = std::less<K>, class A = std::allocator< std::pair<K, V> >> typedef Base::difference_type Loki::AssocVector< K, V, C, A >::difference_type

template<class K, class V, class C = std::less<K>, class A = std::allocator< std::pair<K, V> >> typedef Base::iterator Loki::AssocVector< K, V, C, A >::iterator

template<class K, class V, class C = std::less<K>, class A = std::allocator< std::pair<K, V> >> typedef C Loki::AssocVector< K, V, C, A >::key_compare

template<class K, class V, class C = std::less<K>, class A = std::allocator< std::pair<K, V> >> typedef K Loki::AssocVector< K, V, C, A >::key_type

template<class K, class V, class C = std::less<K>, class A = std::allocator< std::pair<K, V> >> typedef V Loki::AssocVector< K, V, C, A >::mapped_type

template<class K, class V, class C = std::less<K>, class A = std::allocator< std::pair<K, V> >> typedef Private::AssocVectorCompare<V, C> Loki::AssocVector< K, V, C, A >::MyCompare [private]

template<class K, class V, class C = std::less<K>, class A = std::allocator< std::pair<K, V> >> typedef A::pointer Loki::AssocVector< K, V, C, A >::pointer

template<class K, class V, class C = std::less<K>, class A = std::allocator< std::pair<K, V> >> typedef A::reference Loki::AssocVector< K, V, C, A >::reference

template<class K, class V, class C = std::less<K>, class A = std::allocator< std::pair<K, V> >> typedef Base::reverse_iterator Loki::AssocVector< K, V, C, A >::reverse_iterator

template<class K, class V, class C = std::less<K>, class A = std::allocator< std::pair<K, V> >> typedef Base::size_type Loki::AssocVector< K, V, C, A >::size_type

template<class K, class V, class C = std::less<K>, class A = std::allocator< std::pair<K, V> >> typedef Base::value_type Loki::AssocVector< K, V, C, A >::value_type

---

Constructor & Destructor Documentation

template<class K, class V, class C = std::less<K>, class A = std::allocator< std::pair<K, V> >> Loki::AssocVector< K, V, C, A >::AssocVector (  const key_compare &  comp = key_compare(), const A &  alloc = A() )  [inline, explicit]

template<class K, class V, class C = std::less<K>, class A = std::allocator< std::pair<K, V> >> template<class InputIterator> Loki::AssocVector< K, V, C, A >::AssocVector (  InputIterator  first, InputIterator  last, const key_compare &  comp = key_compare(), const A &  alloc = A() )  [inline]

---

Member Function Documentation

template<class K, class V, class C = std::less<K>, class A = std::allocator< std::pair<K, V> >> const_iterator Loki::AssocVector< K, V, C, A >::begin (   )  const [inline]

template<class K, class V, class C = std::less<K>, class A = std::allocator< std::pair<K, V> >> iterator Loki::AssocVector< K, V, C, A >::begin (   )  [inline]

template<class K, class V, class C = std::less<K>, class A = std::allocator< std::pair<K, V> >> void Loki::AssocVector< K, V, C, A >::clear (   )  [inline]

template<class K, class V, class C = std::less<K>, class A = std::allocator< std::pair<K, V> >> size_type Loki::AssocVector< K, V, C, A >::count (  const key_type &  k  )  const [inline]

template<class K, class V, class C = std::less<K>, class A = std::allocator< std::pair<K, V> >> bool Loki::AssocVector< K, V, C, A >::empty (   )  const [inline]

template<class K, class V, class C = std::less<K>, class A = std::allocator< std::pair<K, V> >> const_iterator Loki::AssocVector< K, V, C, A >::end (   )  const [inline]

template<class K, class V, class C = std::less<K>, class A = std::allocator< std::pair<K, V> >> iterator Loki::AssocVector< K, V, C, A >::end (   )  [inline]

template<class K, class V, class C = std::less<K>, class A = std::allocator< std::pair<K, V> >> std::pair<const_iterator, const_iterator> Loki::AssocVector< K, V, C, A >::equal_range (  const key_type &  k  )  const [inline]

template<class K, class V, class C = std::less<K>, class A = std::allocator< std::pair<K, V> >> std::pair<iterator, iterator> Loki::AssocVector< K, V, C, A >::equal_range (  const key_type &  k  )  [inline]

template<class K, class V, class C = std::less<K>, class A = std::allocator< std::pair<K, V> >> void Loki::AssocVector< K, V, C, A >::erase (  iterator  first, iterator  last )  [inline]

template<class K, class V, class C = std::less<K>, class A = std::allocator< std::pair<K, V> >> size_type Loki::AssocVector< K, V, C, A >::erase (  const key_type &  k  )  [inline]

template<class K, class V, class C = std::less<K>, class A = std::allocator< std::pair<K, V> >> void Loki::AssocVector< K, V, C, A >::erase (  iterator  pos  )  [inline]

template<class K, class V, class C = std::less<K>, class A = std::allocator< std::pair<K, V> >> const_iterator Loki::AssocVector< K, V, C, A >::find (  const key_type &  k  )  const [inline]

template<class K, class V, class C = std::less<K>, class A = std::allocator< std::pair<K, V> >> iterator Loki::AssocVector< K, V, C, A >::find (  const key_type &  k  )  [inline]

template<class K, class V, class C = std::less<K>, class A = std::allocator< std::pair<K, V> >> template<class InputIterator> void Loki::AssocVector< K, V, C, A >::insert (  InputIterator  first, InputIterator  last )  [inline]

template<class K, class V, class C = std::less<K>, class A = std::allocator< std::pair<K, V> >> iterator Loki::AssocVector< K, V, C, A >::insert (  iterator  pos, const value_type &  val )  [inline]

template<class K, class V, class C = std::less<K>, class A = std::allocator< std::pair<K, V> >> std::pair<iterator, bool> Loki::AssocVector< K, V, C, A >::insert (  const value_type &  val  )  [inline]

template<class K, class V, class C = std::less<K>, class A = std::allocator< std::pair<K, V> >> key_compare Loki::AssocVector< K, V, C, A >::key_comp (   )  const [inline]

template<class K, class V, class C = std::less<K>, class A = std::allocator< std::pair<K, V> >> const_iterator Loki::AssocVector< K, V, C, A >::lower_bound (  const key_type &  k  )  const [inline]

template<class K, class V, class C = std::less<K>, class A = std::allocator< std::pair<K, V> >> iterator Loki::AssocVector< K, V, C, A >::lower_bound (  const key_type &  k  )  [inline]

template<class K, class V, class C = std::less<K>, class A = std::allocator< std::pair<K, V> >> size_type Loki::AssocVector< K, V, C, A >::max_size (   )  [inline]

template<class K, class V, class C = std::less<K>, class A = std::allocator< std::pair<K, V> >> bool Loki::AssocVector< K, V, C, A >::operator< (  const AssocVector< K, V, C, A > &  rhs  )  const [inline]

template<class K, class V, class C = std::less<K>, class A = std::allocator< std::pair<K, V> >> AssocVector& Loki::AssocVector< K, V, C, A >::operator= (  const AssocVector< K, V, C, A > &  rhs  )  [inline]

template<class K, class V, class C = std::less<K>, class A = std::allocator< std::pair<K, V> >> mapped_type& Loki::AssocVector< K, V, C, A >::operator[] (  const key_type &  key  )  [inline]

template<class K, class V, class C = std::less<K>, class A = std::allocator< std::pair<K, V> >> const_reverse_iterator Loki::AssocVector< K, V, C, A >::rbegin (   )  const [inline]

template<class K, class V, class C = std::less<K>, class A = std::allocator< std::pair<K, V> >> reverse_iterator Loki::AssocVector< K, V, C, A >::rbegin (   )  [inline]

template<class K, class V, class C = std::less<K>, class A = std::allocator< std::pair<K, V> >> const_reverse_iterator Loki::AssocVector< K, V, C, A >::rend (   )  const [inline]

template<class K, class V, class C = std::less<K>, class A = std::allocator< std::pair<K, V> >> reverse_iterator Loki::AssocVector< K, V, C, A >::rend (   )  [inline]

template<class K, class V, class C = std::less<K>, class A = std::allocator< std::pair<K, V> >> size_type Loki::AssocVector< K, V, C, A >::size (   )  const [inline]

template<class K, class V, class C = std::less<K>, class A = std::allocator< std::pair<K, V> >> void Loki::AssocVector< K, V, C, A >::swap (  AssocVector< K, V, C, A > &  other  )  [inline]

template<class K, class V, class C = std::less<K>, class A = std::allocator< std::pair<K, V> >> const_iterator Loki::AssocVector< K, V, C, A >::upper_bound (  const key_type &  k  )  const [inline]

template<class K, class V, class C = std::less<K>, class A = std::allocator< std::pair<K, V> >> iterator Loki::AssocVector< K, V, C, A >::upper_bound (  const key_type &  k  )  [inline]

template<class K, class V, class C = std::less<K>, class A = std::allocator< std::pair<K, V> >> value_compare Loki::AssocVector< K, V, C, A >::value_comp (   )  const [inline]

---

Friends And Related Function Documentation

template<class K, class V, class C = std::less<K>, class A = std::allocator< std::pair<K, V> >> bool operator!= (  const AssocVector< K, V, C, A > &  lhs, const AssocVector< K, V, C, A > &  rhs )  [friend]

template<class K, class V, class C = std::less<K>, class A = std::allocator< std::pair<K, V> >> bool operator<= (  const AssocVector< K, V, C, A > &  lhs, const AssocVector< K, V, C, A > &  rhs )  [friend]

template<class K, class V, class C = std::less<K>, class A = std::allocator< std::pair<K, V> >> bool operator== (  const AssocVector< K, V, C, A > &  lhs, const AssocVector< K, V, C, A > &  rhs )  [friend]

template<class K, class V, class C = std::less<K>, class A = std::allocator< std::pair<K, V> >> bool operator> (  const AssocVector< K, V, C, A > &  lhs, const AssocVector< K, V, C, A > &  rhs )  [friend]

template<class K, class V, class C = std::less<K>, class A = std::allocator< std::pair<K, V> >> bool operator>= (  const AssocVector< K, V, C, A > &  lhs, const AssocVector< K, V, C, A > &  rhs )  [friend]

---

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

• lokiAssocVector.h

---