Main Page   Class Hierarchy   Alphabetical List   Compound List   File List   Compound Members   File Members  

multimap Class Template Reference

#include <stl_multimap.h>

Collaboration diagram for multimap:

Collaboration graph
[legend]
List of all members.

Public Types

typedef Key key_type
typedef T data_type
typedef T mapped_type
typedef pair< const Key, T > value_type
typedef Compare key_compare
typedef rep_type::pointer pointer
typedef rep_type::const_pointer const_pointer
typedef rep_type::reference reference
typedef rep_type::const_reference const_reference
typedef rep_type::iterator iterator
typedef rep_type::const_iterator const_iterator
typedef rep_type::reverse_iterator reverse_iterator
typedef rep_type::const_reverse_iterator const_reverse_iterator
typedef rep_type::size_type size_type
typedef rep_type::difference_type difference_type

Public Methods

 multimap ()
 multimap (const Compare &comp)
 multimap (const value_type *first, const value_type *last)
 multimap (const value_type *first, const value_type *last, const Compare &comp)
 multimap (const_iterator first, const_iterator last)
 multimap (const_iterator first, const_iterator last, const Compare &comp)
 multimap (const multimap< Key, T, Compare, Alloc > &x)
multimap< Key, T, Compare,
Alloc > & 		operator= (const multimap< Key, T, Compare, Alloc > &x)
key_compare key_comp () const
value_compare value_comp () 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
bool empty () const
size_type size () const
size_type max_size () const
void swap (multimap< Key, T, Compare, Alloc > &x)
iterator insert (const value_type &x)
iterator insert (iterator position, const value_type &x)
void insert (const value_type *first, const value_type *last)
void insert (const_iterator first, const_iterator last)
void erase (iterator position)
size_type erase (const key_type &x)
void erase (iterator first, iterator last)
void clear ()
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
pair< iterator, iterator > equal_range (const key_type &x)
pair< const_iterator, const_iterator > equal_range (const key_type &x) const

Private Types

typedef rb_tree< key_type,
value_type, select1st< value_type >,
key_compare, Alloc > 		rep_type

Private Attributes

rep_type t

Friends

bool operator==__STL_NULL_TMPL_ARGS (const multimap &, const multimap &)
bool operator<__STL_NULL_TMPL_ARGS (const multimap &, const multimap &)

template<class Key, class T, class Compare = less<Key>, class Alloc = alloc>
class multimap< Key, T, Compare, Alloc >

Member Typedef Documentation

template<class Key, class T, class Compare = less<Key>, class Alloc = alloc>
typedef rep_type::const_iterator multimap::const_iterator
 

Definition at line 77 of file stl_multimap.h.

Referenced by begin, end, find, insert, lower_bound, multimap, and upper_bound.

template<class Key, class T, class Compare = less<Key>, class Alloc = alloc>
typedef rep_type::const_pointer multimap::const_pointer
 

Definition at line 73 of file stl_multimap.h.

template<class Key, class T, class Compare = less<Key>, class Alloc = alloc>
typedef rep_type::const_reference multimap::const_reference
 

Definition at line 75 of file stl_multimap.h.

template<class Key, class T, class Compare = less<Key>, class Alloc = alloc>
typedef rep_type::const_reverse_iterator multimap::const_reverse_iterator
 

Definition at line 79 of file stl_multimap.h.

Referenced by rbegin, and rend.

template<class Key, class T, class Compare = less<Key>, class Alloc = alloc>
typedef T multimap::data_type
 

Definition at line 51 of file stl_multimap.h.

template<class Key, class T, class Compare = less<Key>, class Alloc = alloc>
typedef rep_type::difference_type multimap::difference_type
 

Definition at line 81 of file stl_multimap.h.

template<class Key, class T, class Compare = less<Key>, class Alloc = alloc>
typedef rep_type::iterator multimap::iterator
 

Definition at line 76 of file stl_multimap.h.

Referenced by begin, end, erase, find, insert, lower_bound, and upper_bound.

template<class Key, class T, class Compare = less<Key>, class Alloc = alloc>
typedef Compare multimap::key_compare
 

Definition at line 54 of file stl_multimap.h.

template<class Key, class T, class Compare = less<Key>, class Alloc = alloc>
typedef Key multimap::key_type
 

Definition at line 50 of file stl_multimap.h.

template<class Key, class T, class Compare = less<Key>, class Alloc = alloc>
typedef T multimap::mapped_type
 

Definition at line 52 of file stl_multimap.h.

template<class Key, class T, class Compare = less<Key>, class Alloc = alloc>
typedef rep_type::pointer multimap::pointer
 

Definition at line 72 of file stl_multimap.h.

template<class Key, class T, class Compare = less<Key>, class Alloc = alloc>
typedef rep_type::reference multimap::reference
 

Definition at line 74 of file stl_multimap.h.

template<class Key, class T, class Compare = less<Key>, class Alloc = alloc>
typedef rb_tree<key_type, value_type, select1st<value_type>, key_compare, Alloc> multimap::rep_type [private]
 

Definition at line 69 of file stl_multimap.h.

template<class Key, class T, class Compare = less<Key>, class Alloc = alloc>
typedef rep_type::reverse_iterator multimap::reverse_iterator
 

Definition at line 78 of file stl_multimap.h.

Referenced by rbegin, and rend.

template<class Key, class T, class Compare = less<Key>, class Alloc = alloc>
typedef rep_type::size_type multimap::size_type
 

Definition at line 80 of file stl_multimap.h.

Referenced by count, erase, max_size, and size.

template<class Key, class T, class Compare = less<Key>, class Alloc = alloc>
typedef pair<const Key, T> multimap::value_type
 

Definition at line 53 of file stl_multimap.h.

Constructor & Destructor Documentation

template<class Key, class T, class Compare = less<Key>, class Alloc = alloc>
multimap< Key, T, Compare, Alloc >::multimap (    )  [inline]
 

Definition at line 85 of file stl_multimap.h. 

00085 : t(Compare()) { }

template<class Key, class T, class Compare = less<Key>, class Alloc = alloc>
multimap< Key, T, Compare, Alloc >::multimap (  const Compare &    comp )  [inline, explicit]
 

Definition at line 86 of file stl_multimap.h. 

00086 : t(comp) { }

template<class Key, class T, class Compare = less<Key>, class Alloc = alloc>
multimap< Key, T, Compare, Alloc >::multimap (  const value_type *    first,
const value_type *    last
)  [inline]
 

Definition at line 97 of file stl_multimap.h.

References rb_tree< key_type, value_type, select1st< value_type >, key_compare, Alloc >::insert_equal. 

00098     : t(Compare()) { t.insert_equal(first, last); }

template<class Key, class T, class Compare = less<Key>, class Alloc = alloc>
multimap< Key, T, Compare, Alloc >::multimap (  const value_type *    first,
const value_type *    last,
const Compare &    comp
)  [inline]
 

Definition at line 99 of file stl_multimap.h.

References rb_tree< key_type, value_type, select1st< value_type >, key_compare, Alloc >::insert_equal. 

00101     : t(comp) { t.insert_equal(first, last); }

template<class Key, class T, class Compare = less<Key>, class Alloc = alloc>
multimap< Key, T, Compare, Alloc >::multimap (  const_iterator    first,
const_iterator    last
)  [inline]
 

Definition at line 103 of file stl_multimap.h.

References const_iterator, and rb_tree< key_type, value_type, select1st< value_type >, key_compare, Alloc >::insert_equal. 

00104     : t(Compare()) { t.insert_equal(first, last); }

template<class Key, class T, class Compare = less<Key>, class Alloc = alloc>
multimap< Key, T, Compare, Alloc >::multimap (  const_iterator    first,
const_iterator    last,
const Compare &    comp
)  [inline]
 

Definition at line 105 of file stl_multimap.h.

References const_iterator, and rb_tree< key_type, value_type, select1st< value_type >, key_compare, Alloc >::insert_equal. 

00106     : t(comp) { t.insert_equal(first, last); }

template<class Key, class T, class Compare = less<Key>, class Alloc = alloc>
multimap< Key, T, Compare, Alloc >::multimap (  const multimap< Key, T, Compare, Alloc > &    x )  [inline]
 

Definition at line 109 of file stl_multimap.h. 

00109 : t(x.t) { }

Member Function Documentation

template<class Key, class T, class Compare = less<Key>, class Alloc = alloc>
const_iterator multimap< Key, T, Compare, Alloc >::begin (    )  const [inline]
 

Definition at line 121 of file stl_multimap.h.

References rb_tree< key_type, value_type, select1st< value_type >, key_compare, Alloc >::begin, and const_iterator. 

00121 { return t.begin(); }

template<class Key, class T, class Compare = less<Key>, class Alloc = alloc>
iterator multimap< Key, T, Compare, Alloc >::begin (    )  [inline]
 

Definition at line 120 of file stl_multimap.h.

References rb_tree< key_type, value_type, select1st< value_type >, key_compare, Alloc >::begin, and iterator. 

00120 { return t.begin(); }

template<class Key, class T, class Compare = less<Key>, class Alloc = alloc>
void multimap< Key, T, Compare, Alloc >::clear (    )  [inline]
 

Definition at line 155 of file stl_multimap.h.

References rb_tree< key_type, value_type, select1st< value_type >, key_compare, Alloc >::clear. 

00155 { t.clear(); }

template<class Key, class T, class Compare = less<Key>, class Alloc = alloc>
size_type multimap< Key, T, Compare, Alloc >::count (  const key_type &    x )  const [inline]
 

Definition at line 161 of file stl_multimap.h.

References rb_tree< key_type, value_type, select1st< value_type >, key_compare, Alloc >::count, and size_type. 

00161 { return t.count(x); }

template<class Key, class T, class Compare = less<Key>, class Alloc = alloc>
bool multimap< Key, T, Compare, Alloc >::empty (    )  const [inline]
 

Definition at line 128 of file stl_multimap.h.

References rb_tree< key_type, value_type, select1st< value_type >, key_compare, Alloc >::empty. 

00128 { return t.empty(); }

template<class Key, class T, class Compare = less<Key>, class Alloc = alloc>
const_iterator multimap< Key, T, Compare, Alloc >::end (    )  const [inline]
 

Definition at line 123 of file stl_multimap.h.

References const_iterator, and rb_tree< key_type, value_type, select1st< value_type >, key_compare, Alloc >::end. 

00123 { return t.end(); }

template<class Key, class T, class Compare = less<Key>, class Alloc = alloc>
iterator multimap< Key, T, Compare, Alloc >::end (    )  [inline]
 

Definition at line 122 of file stl_multimap.h.

References rb_tree< key_type, value_type, select1st< value_type >, key_compare, Alloc >::end, and iterator. 

00122 { return t.end(); }

template<class Key, class T, class Compare = less<Key>, class Alloc = alloc>
pair<const_iterator,const_iterator> multimap< Key, T, Compare, Alloc >::equal_range (  const key_type &    x )  const [inline]
 

Definition at line 173 of file stl_multimap.h.

References rb_tree< key_type, value_type, select1st< value_type >, key_compare, Alloc >::equal_range. 

00173                                                                            {
00174     return t.equal_range(x);
00175   }

template<class Key, class T, class Compare = less<Key>, class Alloc = alloc>
pair<iterator,iterator> multimap< Key, T, Compare, Alloc >::equal_range (  const key_type &    x )  [inline]
 

Definition at line 170 of file stl_multimap.h.

References rb_tree< key_type, value_type, select1st< value_type >, key_compare, Alloc >::equal_range. 

00170                                                           {
00171     return t.equal_range(x);
00172   }

template<class Key, class T, class Compare = less<Key>, class Alloc = alloc>
void multimap< Key, T, Compare, Alloc >::erase (  iterator    first,
iterator    last
)  [inline]
 

Definition at line 154 of file stl_multimap.h.

References rb_tree< key_type, value_type, select1st< value_type >, key_compare, Alloc >::erase, and iterator. 

00154 { t.erase(first, last); }

template<class Key, class T, class Compare = less<Key>, class Alloc = alloc>
size_type multimap< Key, T, Compare, Alloc >::erase (  const key_type &    x )  [inline]
 

Definition at line 153 of file stl_multimap.h.

References rb_tree< key_type, value_type, select1st< value_type >, key_compare, Alloc >::erase, and size_type. 

00153 { return t.erase(x); }

template<class Key, class T, class Compare = less<Key>, class Alloc = alloc>
void multimap< Key, T, Compare, Alloc >::erase (  iterator    position )  [inline]
 

Definition at line 152 of file stl_multimap.h.

References rb_tree< key_type, value_type, select1st< value_type >, key_compare, Alloc >::erase, and iterator. 

00152 { t.erase(position); }

template<class Key, class T, class Compare = less<Key>, class Alloc = alloc>
const_iterator multimap< Key, T, Compare, Alloc >::find (  const key_type &    x )  const [inline]
 

Definition at line 160 of file stl_multimap.h.

References const_iterator, and rb_tree< key_type, value_type, select1st< value_type >, key_compare, Alloc >::find. 

00160 { return t.find(x); }

template<class Key, class T, class Compare = less<Key>, class Alloc = alloc>
iterator multimap< Key, T, Compare, Alloc >::find (  const key_type &    x )  [inline]
 

Definition at line 159 of file stl_multimap.h.

References rb_tree< key_type, value_type, select1st< value_type >, key_compare, Alloc >::find, and iterator. 

00159 { return t.find(x); }

template<class Key, class T, class Compare = less<Key>, class Alloc = alloc>
void multimap< Key, T, Compare, Alloc >::insert (  const_iterator    first,
const_iterator    last
)  [inline]
 

Definition at line 148 of file stl_multimap.h.

References const_iterator, and rb_tree< key_type, value_type, select1st< value_type >, key_compare, Alloc >::insert_equal. 

00148                                                          {
00149     t.insert_equal(first, last);
00150   }

template<class Key, class T, class Compare = less<Key>, class Alloc = alloc>
void multimap< Key, T, Compare, Alloc >::insert (  const value_type *    first,
const value_type *    last
)  [inline]
 

Definition at line 145 of file stl_multimap.h.

References rb_tree< key_type, value_type, select1st< value_type >, key_compare, Alloc >::insert_equal. 

00145                                                                {
00146     t.insert_equal(first, last);
00147   }

template<class Key, class T, class Compare = less<Key>, class Alloc = alloc>
iterator multimap< Key, T, Compare, Alloc >::insert (  iterator    position,
const value_type &    x
)  [inline]
 

Definition at line 136 of file stl_multimap.h.

References rb_tree< key_type, value_type, select1st< value_type >, key_compare, Alloc >::insert_equal, and iterator. 

00136                                                           {
00137     return t.insert_equal(position, x);
00138   }

template<class Key, class T, class Compare = less<Key>, class Alloc = alloc>
iterator multimap< Key, T, Compare, Alloc >::insert (  const value_type &    x )  [inline]
 

Definition at line 135 of file stl_multimap.h.

References rb_tree< key_type, value_type, select1st< value_type >, key_compare, Alloc >::insert_equal, and iterator. 

00135 { return t.insert_equal(x); }

template<class Key, class T, class Compare = less<Key>, class Alloc = alloc>
key_compare multimap< Key, T, Compare, Alloc >::key_comp (    )  const [inline]
 

Definition at line 118 of file stl_multimap.h.

References rb_tree< key_type, value_type, select1st< value_type >, key_compare, Alloc >::key_comp. 

00118 { return t.key_comp(); }

template<class Key, class T, class Compare = less<Key>, class Alloc = alloc>
const_iterator multimap< Key, T, Compare, Alloc >::lower_bound (  const key_type &    x )  const [inline]
 

Definition at line 163 of file stl_multimap.h.

References const_iterator, and rb_tree< key_type, value_type, select1st< value_type >, key_compare, Alloc >::lower_bound. 

00163                                                       {
00164     return t.lower_bound(x); 
00165   }

template<class Key, class T, class Compare = less<Key>, class Alloc = alloc>
iterator multimap< Key, T, Compare, Alloc >::lower_bound (  const key_type &    x )  [inline]
 

Definition at line 162 of file stl_multimap.h.

References iterator, and rb_tree< key_type, value_type, select1st< value_type >, key_compare, Alloc >::lower_bound. 

00162 {return t.lower_bound(x); }

template<class Key, class T, class Compare = less<Key>, class Alloc = alloc>
size_type multimap< Key, T, Compare, Alloc >::max_size (    )  const [inline]
 

Definition at line 130 of file stl_multimap.h.

References rb_tree< key_type, value_type, select1st< value_type >, key_compare, Alloc >::max_size, and size_type. 

00130 { return t.max_size(); }

template<class Key, class T, class Compare = less<Key>, class Alloc = alloc>
multimap<Key, T, Compare, Alloc>& multimap< Key, T, Compare, Alloc >::operator= (  const multimap< Key, T, Compare, Alloc > &    x )  [inline]
 

Definition at line 111 of file stl_multimap.h.

References t. 

00111                                                        {
00112     t = x.t;
00113     return *this; 
00114   }

template<class Key, class T, class Compare = less<Key>, class Alloc = alloc>
const_reverse_iterator multimap< Key, T, Compare, Alloc >::rbegin (    )  const [inline]
 

Definition at line 125 of file stl_multimap.h.

References const_reverse_iterator, and rb_tree< key_type, value_type, select1st< value_type >, key_compare, Alloc >::rbegin. 

00125 { return t.rbegin(); }

template<class Key, class T, class Compare = less<Key>, class Alloc = alloc>
reverse_iterator multimap< Key, T, Compare, Alloc >::rbegin (    )  [inline]
 

Definition at line 124 of file stl_multimap.h.

References rb_tree< key_type, value_type, select1st< value_type >, key_compare, Alloc >::rbegin, and reverse_iterator. 

00124 { return t.rbegin(); }

template<class Key, class T, class Compare = less<Key>, class Alloc = alloc>
const_reverse_iterator multimap< Key, T, Compare, Alloc >::rend (    )  const [inline]
 

Definition at line 127 of file stl_multimap.h.

References const_reverse_iterator, and rb_tree< key_type, value_type, select1st< value_type >, key_compare, Alloc >::rend. 

00127 { return t.rend(); }

template<class Key, class T, class Compare = less<Key>, class Alloc = alloc>
reverse_iterator multimap< Key, T, Compare, Alloc >::rend (    )  [inline]
 

Definition at line 126 of file stl_multimap.h.

References rb_tree< key_type, value_type, select1st< value_type >, key_compare, Alloc >::rend, and reverse_iterator. 

00126 { return t.rend(); }

template<class Key, class T, class Compare = less<Key>, class Alloc = alloc>
size_type multimap< Key, T, Compare, Alloc >::size (    )  const [inline]
 

Definition at line 129 of file stl_multimap.h.

References rb_tree< key_type, value_type, select1st< value_type >, key_compare, Alloc >::size, and size_type. 

00129 { return t.size(); }

template<class Key, class T, class Compare = less<Key>, class Alloc = alloc>
void multimap< Key, T, Compare, Alloc >::swap (  multimap< Key, T, Compare, Alloc > &    x )  [inline]
 

Definition at line 131 of file stl_multimap.h.

References rb_tree< key_type, value_type, select1st< value_type >, key_compare, Alloc >::swap, and t. 

00131 { t.swap(x.t); }

template<class Key, class T, class Compare = less<Key>, class Alloc = alloc>
const_iterator multimap< Key, T, Compare, Alloc >::upper_bound (  const key_type &    x )  const [inline]
 

Definition at line 167 of file stl_multimap.h.

References const_iterator, and rb_tree< key_type, value_type, select1st< value_type >, key_compare, Alloc >::upper_bound. 

00167                                                       {
00168     return t.upper_bound(x); 
00169   }

template<class Key, class T, class Compare = less<Key>, class Alloc = alloc>
iterator multimap< Key, T, Compare, Alloc >::upper_bound (  const key_type &    x )  [inline]
 

Definition at line 166 of file stl_multimap.h.

References iterator, and rb_tree< key_type, value_type, select1st< value_type >, key_compare, Alloc >::upper_bound. 

00166 {return t.upper_bound(x); }

template<class Key, class T, class Compare = less<Key>, class Alloc = alloc>
value_compare multimap< Key, T, Compare, Alloc >::value_comp (    )  const [inline]
 

Definition at line 119 of file stl_multimap.h.

References rb_tree< key_type, value_type, select1st< value_type >, key_compare, Alloc >::key_comp. 

00119 { return value_compare(t.key_comp()); }

Friends And Related Function Documentation

template<class Key, class T, class Compare = less<Key>, class Alloc = alloc>
bool operator<__STL_NULL_TMPL_ARGS (  const multimap< Key, T, Compare, Alloc > &   ,
const multimap< Key, T, Compare, Alloc > &   
)  [friend]
 

template<class Key, class T, class Compare = less<Key>, class Alloc = alloc>
bool operator==__STL_NULL_TMPL_ARGS (  const multimap< Key, T, Compare, Alloc > &   ,
const multimap< Key, T, Compare, Alloc > &   
)  [friend]
 

Member Data Documentation

template<class Key, class T, class Compare = less<Key>, class Alloc = alloc>
rep_type multimap::t [private]
 

Definition at line 70 of file stl_multimap.h.

Referenced by operator=, operator==, and swap.

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

Documentation generated on Thu May 2 15:03:36 2002

Generated with doxygen 1.2.12 by Dimitri van Heesch ,   1997-2001