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

hash_map Class Template Reference

#include <stl_hash_map.h>

Collaboration diagram for hash_map:

Collaboration graph
[legend]
List of all members.

Public Types

typedef ht::key_type key_type
typedef T data_type
typedef T mapped_type
typedef ht::value_type value_type
typedef ht::hasher hasher
typedef ht::key_equal key_equal
typedef ht::size_type size_type
typedef ht::difference_type difference_type
typedef ht::pointer pointer
typedef ht::const_pointer const_pointer
typedef ht::reference reference
typedef ht::const_reference const_reference
typedef ht::iterator iterator
typedef ht::const_iterator const_iterator

Public Methods

hasher hash_funct () const
key_equal key_eq () const
 hash_map ()
 hash_map (size_type n)
 hash_map (size_type n, const hasher &hf)
 hash_map (size_type n, const hasher &hf, const key_equal &eql)
 hash_map (const value_type *f, const value_type *l)
 hash_map (const value_type *f, const value_type *l, size_type n)
 hash_map (const value_type *f, const value_type *l, size_type n, const hasher &hf)
 hash_map (const value_type *f, const value_type *l, size_type n, const hasher &hf, const key_equal &eql)
 hash_map (const_iterator f, const_iterator l)
 hash_map (const_iterator f, const_iterator l, size_type n)
 hash_map (const_iterator f, const_iterator l, size_type n, const hasher &hf)
 hash_map (const_iterator f, const_iterator l, size_type n, const hasher &hf, const key_equal &eql)
size_type size () const
size_type max_size () const
bool empty () const
void swap (hash_map &hs)
iterator begin ()
iterator end ()
const_iterator begin () const
const_iterator end () const
pair< iterator, bool > insert (const value_type &obj)
void insert (const value_type *f, const value_type *l)
void insert (const_iterator f, const_iterator l)
pair< iterator, bool > insert_noresize (const value_type &obj)
iterator find (const key_type &key)
const_iterator find (const key_type &key) const
T & operator[] (const key_type &key)
size_type count (const key_type &key) const
pair< iterator, iterator > equal_range (const key_type &key)
pair< const_iterator, const_iterator > equal_range (const key_type &key) const
size_type erase (const key_type &key)
void erase (iterator it)
void erase (iterator f, iterator l)
void clear ()
void resize (size_type hint)
size_type bucket_count () const
size_type max_bucket_count () const
size_type elems_in_bucket (size_type n) const

Private Types

typedef hashtable< pair< const
Key, T >, Key, HashFcn, select1st<
pair< const Key, T > >, EqualKey,
Alloc > 		ht

Private Attributes

ht rep

Friends

bool operator==__STL_NULL_TMPL_ARGS (const hash_map &, const hash_map &)

template<class Key, class T, class HashFcn = hash<Key>, class EqualKey = equal_to<Key>, class Alloc = alloc>
class hash_map< Key, T, HashFcn, EqualKey, Alloc >

Member Typedef Documentation

template<class Key, class T, class HashFcn = hash<Key>, class EqualKey = equal_to<Key>, class Alloc = alloc>
typedef ht::const_iterator hash_map::const_iterator
 

Definition at line 72 of file stl_hash_map.h.

Referenced by begin, end, find, hash_map, and insert.

template<class Key, class T, class HashFcn = hash<Key>, class EqualKey = equal_to<Key>, class Alloc = alloc>
typedef ht::const_pointer hash_map::const_pointer
 

Definition at line 67 of file stl_hash_map.h.

template<class Key, class T, class HashFcn = hash<Key>, class EqualKey = equal_to<Key>, class Alloc = alloc>
typedef ht::const_reference hash_map::const_reference
 

Definition at line 69 of file stl_hash_map.h.

template<class Key, class T, class HashFcn = hash<Key>, class EqualKey = equal_to<Key>, class Alloc = alloc>
typedef T hash_map::data_type
 

Definition at line 58 of file stl_hash_map.h.

template<class Key, class T, class HashFcn = hash<Key>, class EqualKey = equal_to<Key>, class Alloc = alloc>
typedef ht::difference_type hash_map::difference_type
 

Definition at line 65 of file stl_hash_map.h.

template<class Key, class T, class HashFcn = hash<Key>, class EqualKey = equal_to<Key>, class Alloc = alloc>
typedef ht::hasher hash_map::hasher
 

Definition at line 61 of file stl_hash_map.h.

Referenced by hash_funct, and hash_map.

template<class Key, class T, class HashFcn = hash<Key>, class EqualKey = equal_to<Key>, class Alloc = alloc>
typedef hashtable<pair<const Key, T>, Key, HashFcn, select1st<pair<const Key, T> >, EqualKey, Alloc> hash_map::ht [private]
 

Definition at line 53 of file stl_hash_map.h.

template<class Key, class T, class HashFcn = hash<Key>, class EqualKey = equal_to<Key>, class Alloc = alloc>
typedef ht::iterator hash_map::iterator
 

Definition at line 71 of file stl_hash_map.h.

Referenced by begin, end, erase, and find.

template<class Key, class T, class HashFcn = hash<Key>, class EqualKey = equal_to<Key>, class Alloc = alloc>
typedef ht::key_equal hash_map::key_equal
 

Definition at line 62 of file stl_hash_map.h.

Referenced by hash_map, and key_eq.

template<class Key, class T, class HashFcn = hash<Key>, class EqualKey = equal_to<Key>, class Alloc = alloc>
typedef ht::key_type hash_map::key_type
 

Definition at line 57 of file stl_hash_map.h.

Referenced by count, equal_range, erase, find, and operator[].

template<class Key, class T, class HashFcn = hash<Key>, class EqualKey = equal_to<Key>, class Alloc = alloc>
typedef T hash_map::mapped_type
 

Definition at line 59 of file stl_hash_map.h.

template<class Key, class T, class HashFcn = hash<Key>, class EqualKey = equal_to<Key>, class Alloc = alloc>
typedef ht::pointer hash_map::pointer
 

Definition at line 66 of file stl_hash_map.h.

template<class Key, class T, class HashFcn = hash<Key>, class EqualKey = equal_to<Key>, class Alloc = alloc>
typedef ht::reference hash_map::reference
 

Definition at line 68 of file stl_hash_map.h.

template<class Key, class T, class HashFcn = hash<Key>, class EqualKey = equal_to<Key>, class Alloc = alloc>
typedef ht::size_type hash_map::size_type
 

Definition at line 64 of file stl_hash_map.h.

Referenced by bucket_count, count, elems_in_bucket, erase, hash_map, max_bucket_count, max_size, resize, and size.

template<class Key, class T, class HashFcn = hash<Key>, class EqualKey = equal_to<Key>, class Alloc = alloc>
typedef ht::value_type hash_map::value_type
 

Definition at line 60 of file stl_hash_map.h.

Referenced by hash_map, insert, insert_noresize, and operator[].

Constructor & Destructor Documentation

template<class Key, class T, class HashFcn = hash<Key>, class EqualKey = equal_to<Key>, class Alloc = alloc>
hash_map< Key, T, HashFcn, EqualKey, Alloc >::hash_map (    )  [inline]
 

Definition at line 78 of file stl_hash_map.h.

References hasher, and key_equal. 

00078 : rep(100, hasher(), key_equal()) {}

template<class Key, class T, class HashFcn = hash<Key>, class EqualKey = equal_to<Key>, class Alloc = alloc>
hash_map< Key, T, HashFcn, EqualKey, Alloc >::hash_map (  size_type    n )  [inline, explicit]
 

Definition at line 79 of file stl_hash_map.h.

References hasher, key_equal, and size_type. 

00079 : rep(n, hasher(), key_equal()) {}

template<class Key, class T, class HashFcn = hash<Key>, class EqualKey = equal_to<Key>, class Alloc = alloc>
hash_map< Key, T, HashFcn, EqualKey, Alloc >::hash_map (  size_type    n,
const hasher &    hf
)  [inline]
 

Definition at line 80 of file stl_hash_map.h.

References hasher, key_equal, and size_type. 

00080 : rep(n, hf, key_equal()) {}

template<class Key, class T, class HashFcn = hash<Key>, class EqualKey = equal_to<Key>, class Alloc = alloc>
hash_map< Key, T, HashFcn, EqualKey, Alloc >::hash_map (  size_type    n,
const hasher &    hf,
const key_equal &    eql
)  [inline]
 

Definition at line 81 of file stl_hash_map.h.

References hasher, key_equal, and size_type. 

00082     : rep(n, hf, eql) {}

template<class Key, class T, class HashFcn = hash<Key>, class EqualKey = equal_to<Key>, class Alloc = alloc>
hash_map< Key, T, HashFcn, EqualKey, Alloc >::hash_map (  const value_type *    f,
const value_type *    l
)  [inline]
 

Definition at line 101 of file stl_hash_map.h.

References hasher, hashtable< pair< const Key, T >, Key, HashFcn, select1st< pair< const Key, T > >, EqualKey, Alloc >::insert_unique, key_equal, and value_type. 

00102     : rep(100, hasher(), key_equal()) { rep.insert_unique(f, l); }

template<class Key, class T, class HashFcn = hash<Key>, class EqualKey = equal_to<Key>, class Alloc = alloc>
hash_map< Key, T, HashFcn, EqualKey, Alloc >::hash_map (  const value_type *    f,
const value_type *    l,
size_type    n
)  [inline]
 

Definition at line 103 of file stl_hash_map.h.

References hasher, hashtable< pair< const Key, T >, Key, HashFcn, select1st< pair< const Key, T > >, EqualKey, Alloc >::insert_unique, key_equal, size_type, and value_type. 

00104     : rep(n, hasher(), key_equal()) { rep.insert_unique(f, l); }

template<class Key, class T, class HashFcn = hash<Key>, class EqualKey = equal_to<Key>, class Alloc = alloc>
hash_map< Key, T, HashFcn, EqualKey, Alloc >::hash_map (  const value_type *    f,
const value_type *    l,
size_type    n,
const hasher &    hf
)  [inline]
 

Definition at line 105 of file stl_hash_map.h.

References hasher, hashtable< pair< const Key, T >, Key, HashFcn, select1st< pair< const Key, T > >, EqualKey, Alloc >::insert_unique, key_equal, size_type, and value_type. 

00107     : rep(n, hf, key_equal()) { rep.insert_unique(f, l); }

template<class Key, class T, class HashFcn = hash<Key>, class EqualKey = equal_to<Key>, class Alloc = alloc>
hash_map< Key, T, HashFcn, EqualKey, Alloc >::hash_map (  const value_type *    f,
const value_type *    l,
size_type    n,
const hasher &    hf,
const key_equal &    eql
)  [inline]
 

Definition at line 108 of file stl_hash_map.h.

References hasher, hashtable< pair< const Key, T >, Key, HashFcn, select1st< pair< const Key, T > >, EqualKey, Alloc >::insert_unique, key_equal, size_type, and value_type. 

00110     : rep(n, hf, eql) { rep.insert_unique(f, l); }

template<class Key, class T, class HashFcn = hash<Key>, class EqualKey = equal_to<Key>, class Alloc = alloc>
hash_map< Key, T, HashFcn, EqualKey, Alloc >::hash_map (  const_iterator    f,
const_iterator    l
)  [inline]
 

Definition at line 112 of file stl_hash_map.h.

References const_iterator, hasher, hashtable< pair< const Key, T >, Key, HashFcn, select1st< pair< const Key, T > >, EqualKey, Alloc >::insert_unique, and key_equal. 

00113     : rep(100, hasher(), key_equal()) { rep.insert_unique(f, l); }

template<class Key, class T, class HashFcn = hash<Key>, class EqualKey = equal_to<Key>, class Alloc = alloc>
hash_map< Key, T, HashFcn, EqualKey, Alloc >::hash_map (  const_iterator    f,
const_iterator    l,
size_type    n
)  [inline]
 

Definition at line 114 of file stl_hash_map.h.

References const_iterator, hasher, hashtable< pair< const Key, T >, Key, HashFcn, select1st< pair< const Key, T > >, EqualKey, Alloc >::insert_unique, key_equal, and size_type. 

00115     : rep(n, hasher(), key_equal()) { rep.insert_unique(f, l); }

template<class Key, class T, class HashFcn = hash<Key>, class EqualKey = equal_to<Key>, class Alloc = alloc>
hash_map< Key, T, HashFcn, EqualKey, Alloc >::hash_map (  const_iterator    f,
const_iterator    l,
size_type    n,
const hasher &    hf
)  [inline]
 

Definition at line 116 of file stl_hash_map.h.

References const_iterator, hasher, hashtable< pair< const Key, T >, Key, HashFcn, select1st< pair< const Key, T > >, EqualKey, Alloc >::insert_unique, key_equal, and size_type. 

00118     : rep(n, hf, key_equal()) { rep.insert_unique(f, l); }

template<class Key, class T, class HashFcn = hash<Key>, class EqualKey = equal_to<Key>, class Alloc = alloc>
hash_map< Key, T, HashFcn, EqualKey, Alloc >::hash_map (  const_iterator    f,
const_iterator    l,
size_type    n,
const hasher &    hf,
const key_equal &    eql
)  [inline]
 

Definition at line 119 of file stl_hash_map.h.

References const_iterator, hasher, hashtable< pair< const Key, T >, Key, HashFcn, select1st< pair< const Key, T > >, EqualKey, Alloc >::insert_unique, key_equal, and size_type. 

00121     : rep(n, hf, eql) { rep.insert_unique(f, l); }

Member Function Documentation

template<class Key, class T, class HashFcn = hash<Key>, class EqualKey = equal_to<Key>, class Alloc = alloc>
const_iterator hash_map< Key, T, HashFcn, EqualKey, Alloc >::begin (    )  const [inline]
 

Definition at line 134 of file stl_hash_map.h.

References hashtable< pair< const Key, T >, Key, HashFcn, select1st< pair< const Key, T > >, EqualKey, Alloc >::begin, and const_iterator. 

00134 { return rep.begin(); }

template<class Key, class T, class HashFcn = hash<Key>, class EqualKey = equal_to<Key>, class Alloc = alloc>
iterator hash_map< Key, T, HashFcn, EqualKey, Alloc >::begin (    )  [inline]
 

Definition at line 132 of file stl_hash_map.h.

References hashtable< pair< const Key, T >, Key, HashFcn, select1st< pair< const Key, T > >, EqualKey, Alloc >::begin, and iterator. 

00132 { return rep.begin(); }

template<class Key, class T, class HashFcn = hash<Key>, class EqualKey = equal_to<Key>, class Alloc = alloc>
size_type hash_map< Key, T, HashFcn, EqualKey, Alloc >::bucket_count (    )  const [inline]
 

Definition at line 173 of file stl_hash_map.h.

References hashtable< pair< const Key, T >, Key, HashFcn, select1st< pair< const Key, T > >, EqualKey, Alloc >::bucket_count, and size_type. 

00173 { return rep.bucket_count(); }

template<class Key, class T, class HashFcn = hash<Key>, class EqualKey = equal_to<Key>, class Alloc = alloc>
void hash_map< Key, T, HashFcn, EqualKey, Alloc >::clear (    )  [inline]
 

Definition at line 169 of file stl_hash_map.h.

References hashtable< pair< const Key, T >, Key, HashFcn, select1st< pair< const Key, T > >, EqualKey, Alloc >::clear. 

00169 { rep.clear(); }

template<class Key, class T, class HashFcn = hash<Key>, class EqualKey = equal_to<Key>, class Alloc = alloc>
size_type hash_map< Key, T, HashFcn, EqualKey, Alloc >::count (  const key_type &    key )  const [inline]
 

Definition at line 159 of file stl_hash_map.h.

References hashtable< pair< const Key, T >, Key, HashFcn, select1st< pair< const Key, T > >, EqualKey, Alloc >::count, key_type, and size_type. 

00159 { return rep.count(key); }

template<class Key, class T, class HashFcn = hash<Key>, class EqualKey = equal_to<Key>, class Alloc = alloc>
size_type hash_map< Key, T, HashFcn, EqualKey, Alloc >::elems_in_bucket (  size_type    n )  const [inline]
 

Definition at line 175 of file stl_hash_map.h.

References hashtable< pair< const Key, T >, Key, HashFcn, select1st< pair< const Key, T > >, EqualKey, Alloc >::elems_in_bucket, and size_type. 

00176     { return rep.elems_in_bucket(n); }

template<class Key, class T, class HashFcn = hash<Key>, class EqualKey = equal_to<Key>, class Alloc = alloc>
bool hash_map< Key, T, HashFcn, EqualKey, Alloc >::empty (    )  const [inline]
 

Definition at line 127 of file stl_hash_map.h.

References hashtable< pair< const Key, T >, Key, HashFcn, select1st< pair< const Key, T > >, EqualKey, Alloc >::empty. 

00127 { return rep.empty(); }

template<class Key, class T, class HashFcn = hash<Key>, class EqualKey = equal_to<Key>, class Alloc = alloc>
const_iterator hash_map< Key, T, HashFcn, EqualKey, Alloc >::end (    )  const [inline]
 

Definition at line 135 of file stl_hash_map.h.

References const_iterator, and hashtable< pair< const Key, T >, Key, HashFcn, select1st< pair< const Key, T > >, EqualKey, Alloc >::end. 

00135 { return rep.end(); }

template<class Key, class T, class HashFcn = hash<Key>, class EqualKey = equal_to<Key>, class Alloc = alloc>
iterator hash_map< Key, T, HashFcn, EqualKey, Alloc >::end (    )  [inline]
 

Definition at line 133 of file stl_hash_map.h.

References hashtable< pair< const Key, T >, Key, HashFcn, select1st< pair< const Key, T > >, EqualKey, Alloc >::end, and iterator. 

00133 { return rep.end(); }

template<class Key, class T, class HashFcn = hash<Key>, class EqualKey = equal_to<Key>, class Alloc = alloc>
pair<const_iterator, const_iterator> hash_map< Key, T, HashFcn, EqualKey, Alloc >::equal_range (  const key_type &    key )  const [inline]
 

Definition at line 163 of file stl_hash_map.h.

References hashtable< pair< const Key, T >, Key, HashFcn, select1st< pair< const Key, T > >, EqualKey, Alloc >::equal_range, and key_type. 

00164     { return rep.equal_range(key); }

template<class Key, class T, class HashFcn = hash<Key>, class EqualKey = equal_to<Key>, class Alloc = alloc>
pair<iterator, iterator> hash_map< Key, T, HashFcn, EqualKey, Alloc >::equal_range (  const key_type &    key )  [inline]
 

Definition at line 161 of file stl_hash_map.h.

References hashtable< pair< const Key, T >, Key, HashFcn, select1st< pair< const Key, T > >, EqualKey, Alloc >::equal_range, and key_type. 

00162     { return rep.equal_range(key); }

template<class Key, class T, class HashFcn = hash<Key>, class EqualKey = equal_to<Key>, class Alloc = alloc>
void hash_map< Key, T, HashFcn, EqualKey, Alloc >::erase (  iterator    f,
iterator    l
)  [inline]
 

Definition at line 168 of file stl_hash_map.h.

References hashtable< pair< const Key, T >, Key, HashFcn, select1st< pair< const Key, T > >, EqualKey, Alloc >::erase, and iterator. 

00168 { rep.erase(f, l); }

template<class Key, class T, class HashFcn = hash<Key>, class EqualKey = equal_to<Key>, class Alloc = alloc>
void hash_map< Key, T, HashFcn, EqualKey, Alloc >::erase (  iterator    it )  [inline]
 

Definition at line 167 of file stl_hash_map.h.

References hashtable< pair< const Key, T >, Key, HashFcn, select1st< pair< const Key, T > >, EqualKey, Alloc >::erase, and iterator. 

00167 { rep.erase(it); }

template<class Key, class T, class HashFcn = hash<Key>, class EqualKey = equal_to<Key>, class Alloc = alloc>
size_type hash_map< Key, T, HashFcn, EqualKey, Alloc >::erase (  const key_type &    key )  [inline]
 

Definition at line 166 of file stl_hash_map.h.

References hashtable< pair< const Key, T >, Key, HashFcn, select1st< pair< const Key, T > >, EqualKey, Alloc >::erase, key_type, and size_type. 

00166 {return rep.erase(key); }

template<class Key, class T, class HashFcn = hash<Key>, class EqualKey = equal_to<Key>, class Alloc = alloc>
const_iterator hash_map< Key, T, HashFcn, EqualKey, Alloc >::find (  const key_type &    key )  const [inline]
 

Definition at line 153 of file stl_hash_map.h.

References const_iterator, hashtable< pair< const Key, T >, Key, HashFcn, select1st< pair< const Key, T > >, EqualKey, Alloc >::find, and key_type. 

00153 { return rep.find(key); }

template<class Key, class T, class HashFcn = hash<Key>, class EqualKey = equal_to<Key>, class Alloc = alloc>
iterator hash_map< Key, T, HashFcn, EqualKey, Alloc >::find (  const key_type &    key )  [inline]
 

Definition at line 152 of file stl_hash_map.h.

References hashtable< pair< const Key, T >, Key, HashFcn, select1st< pair< const Key, T > >, EqualKey, Alloc >::find, iterator, and key_type. 

00152 { return rep.find(key); }

template<class Key, class T, class HashFcn = hash<Key>, class EqualKey = equal_to<Key>, class Alloc = alloc>
hasher hash_map< Key, T, HashFcn, EqualKey, Alloc >::hash_funct (    )  const [inline]
 

Definition at line 74 of file stl_hash_map.h.

References hashtable< pair< const Key, T >, Key, HashFcn, select1st< pair< const Key, T > >, EqualKey, Alloc >::hash_funct, and hasher. 

00074 { return rep.hash_funct(); }

template<class Key, class T, class HashFcn = hash<Key>, class EqualKey = equal_to<Key>, class Alloc = alloc>
void hash_map< Key, T, HashFcn, EqualKey, Alloc >::insert (  const_iterator    f,
const_iterator    l
)  [inline]
 

Definition at line 147 of file stl_hash_map.h.

References const_iterator, and hashtable< pair< const Key, T >, Key, HashFcn, select1st< pair< const Key, T > >, EqualKey, Alloc >::insert_unique. 

00147 { rep.insert_unique(f, l); }

template<class Key, class T, class HashFcn = hash<Key>, class EqualKey = equal_to<Key>, class Alloc = alloc>
void hash_map< Key, T, HashFcn, EqualKey, Alloc >::insert (  const value_type *    f,
const value_type *    l
)  [inline]
 

Definition at line 144 of file stl_hash_map.h.

References hashtable< pair< const Key, T >, Key, HashFcn, select1st< pair< const Key, T > >, EqualKey, Alloc >::insert_unique, and value_type. 

00144                                                         {
00145     rep.insert_unique(f,l);
00146   }

template<class Key, class T, class HashFcn = hash<Key>, class EqualKey = equal_to<Key>, class Alloc = alloc>
pair<iterator, bool> hash_map< Key, T, HashFcn, EqualKey, Alloc >::insert (  const value_type &    obj )  [inline]
 

Definition at line 138 of file stl_hash_map.h.

References hashtable< pair< const Key, T >, Key, HashFcn, select1st< pair< const Key, T > >, EqualKey, Alloc >::insert_unique, and value_type. 

00139     { return rep.insert_unique(obj); }

template<class Key, class T, class HashFcn = hash<Key>, class EqualKey = equal_to<Key>, class Alloc = alloc>
pair<iterator, bool> hash_map< Key, T, HashFcn, EqualKey, Alloc >::insert_noresize (  const value_type &    obj )  [inline]
 

Definition at line 149 of file stl_hash_map.h.

References hashtable< pair< const Key, T >, Key, HashFcn, select1st< pair< const Key, T > >, EqualKey, Alloc >::insert_unique_noresize, and value_type. 

00150     { return rep.insert_unique_noresize(obj); }

template<class Key, class T, class HashFcn = hash<Key>, class EqualKey = equal_to<Key>, class Alloc = alloc>
key_equal hash_map< Key, T, HashFcn, EqualKey, Alloc >::key_eq (    )  const [inline]
 

Definition at line 75 of file stl_hash_map.h.

References hashtable< pair< const Key, T >, Key, HashFcn, select1st< pair< const Key, T > >, EqualKey, Alloc >::key_eq, and key_equal. 

00075 { return rep.key_eq(); }

template<class Key, class T, class HashFcn = hash<Key>, class EqualKey = equal_to<Key>, class Alloc = alloc>
size_type hash_map< Key, T, HashFcn, EqualKey, Alloc >::max_bucket_count (    )  const [inline]
 

Definition at line 174 of file stl_hash_map.h.

References hashtable< pair< const Key, T >, Key, HashFcn, select1st< pair< const Key, T > >, EqualKey, Alloc >::max_bucket_count, and size_type. 

00174 { return rep.max_bucket_count(); }

template<class Key, class T, class HashFcn = hash<Key>, class EqualKey = equal_to<Key>, class Alloc = alloc>
size_type hash_map< Key, T, HashFcn, EqualKey, Alloc >::max_size (    )  const [inline]
 

Definition at line 126 of file stl_hash_map.h.

References hashtable< pair< const Key, T >, Key, HashFcn, select1st< pair< const Key, T > >, EqualKey, Alloc >::max_size, and size_type. 

00126 { return rep.max_size(); }

template<class Key, class T, class HashFcn = hash<Key>, class EqualKey = equal_to<Key>, class Alloc = alloc>
T& hash_map< Key, T, HashFcn, EqualKey, Alloc >::operator[] (  const key_type &    key )  [inline]
 

Definition at line 155 of file stl_hash_map.h.

References hashtable< pair< const Key, T >, Key, HashFcn, select1st< pair< const Key, T > >, EqualKey, Alloc >::find_or_insert, key_type, and value_type. 

00155                                      {
00156     return rep.find_or_insert(value_type(key, T())).second;
00157   }

template<class Key, class T, class HashFcn = hash<Key>, class EqualKey = equal_to<Key>, class Alloc = alloc>
void hash_map< Key, T, HashFcn, EqualKey, Alloc >::resize (  size_type    hint )  [inline]
 

Definition at line 172 of file stl_hash_map.h.

References hashtable< pair< const Key, T >, Key, HashFcn, select1st< pair< const Key, T > >, EqualKey, Alloc >::resize, and size_type. 

00172 { rep.resize(hint); }

template<class Key, class T, class HashFcn = hash<Key>, class EqualKey = equal_to<Key>, class Alloc = alloc>
size_type hash_map< Key, T, HashFcn, EqualKey, Alloc >::size (    )  const [inline]
 

Definition at line 125 of file stl_hash_map.h.

References hashtable< pair< const Key, T >, Key, HashFcn, select1st< pair< const Key, T > >, EqualKey, Alloc >::size, and size_type. 

00125 { return rep.size(); }

template<class Key, class T, class HashFcn = hash<Key>, class EqualKey = equal_to<Key>, class Alloc = alloc>
void hash_map< Key, T, HashFcn, EqualKey, Alloc >::swap (  hash_map< Key, T, HashFcn, EqualKey, Alloc > &    hs )  [inline]
 

Definition at line 128 of file stl_hash_map.h.

References rep, and hashtable< pair< const Key, T >, Key, HashFcn, select1st< pair< const Key, T > >, EqualKey, Alloc >::swap. 

00128 { rep.swap(hs.rep); }

Friends And Related Function Documentation

template<class Key, class T, class HashFcn = hash<Key>, class EqualKey = equal_to<Key>, class Alloc = alloc>
bool operator==__STL_NULL_TMPL_ARGS (  const hash_map< Key, T, HashFcn, EqualKey, Alloc > &   ,
const hash_map< Key, T, HashFcn, EqualKey, Alloc > &   
)  [friend]
 

Member Data Documentation

template<class Key, class T, class HashFcn = hash<Key>, class EqualKey = equal_to<Key>, class Alloc = alloc>
ht hash_map::rep [private]
 

Definition at line 54 of file stl_hash_map.h.

Referenced by operator==, and swap.

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

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

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