google_hash 0.0.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (85) hide show
  1. data/README +21 -0
  2. data/Rakefile +11 -0
  3. data/VERSION +1 -0
  4. data/ext/extconf.rb +15 -0
  5. data/ext/go.cpp +109 -0
  6. data/ext/sparsehash-1.5.2/AUTHORS +2 -0
  7. data/ext/sparsehash-1.5.2/COPYING +28 -0
  8. data/ext/sparsehash-1.5.2/ChangeLog +167 -0
  9. data/ext/sparsehash-1.5.2/INSTALL +236 -0
  10. data/ext/sparsehash-1.5.2/Makefile.am +157 -0
  11. data/ext/sparsehash-1.5.2/Makefile.in +1019 -0
  12. data/ext/sparsehash-1.5.2/NEWS +0 -0
  13. data/ext/sparsehash-1.5.2/README +149 -0
  14. data/ext/sparsehash-1.5.2/README.windows +25 -0
  15. data/ext/sparsehash-1.5.2/TODO +28 -0
  16. data/ext/sparsehash-1.5.2/aclocal.m4 +868 -0
  17. data/ext/sparsehash-1.5.2/compile +99 -0
  18. data/ext/sparsehash-1.5.2/config.guess +1516 -0
  19. data/ext/sparsehash-1.5.2/config.sub +1626 -0
  20. data/ext/sparsehash-1.5.2/configure +8054 -0
  21. data/ext/sparsehash-1.5.2/configure.ac +74 -0
  22. data/ext/sparsehash-1.5.2/depcomp +530 -0
  23. data/ext/sparsehash-1.5.2/doc/dense_hash_map.html +1591 -0
  24. data/ext/sparsehash-1.5.2/doc/dense_hash_set.html +1445 -0
  25. data/ext/sparsehash-1.5.2/doc/designstyle.css +115 -0
  26. data/ext/sparsehash-1.5.2/doc/implementation.html +365 -0
  27. data/ext/sparsehash-1.5.2/doc/index.html +69 -0
  28. data/ext/sparsehash-1.5.2/doc/performance.html +96 -0
  29. data/ext/sparsehash-1.5.2/doc/sparse_hash_map.html +1527 -0
  30. data/ext/sparsehash-1.5.2/doc/sparse_hash_set.html +1376 -0
  31. data/ext/sparsehash-1.5.2/doc/sparsetable.html +1393 -0
  32. data/ext/sparsehash-1.5.2/experimental/Makefile +9 -0
  33. data/ext/sparsehash-1.5.2/experimental/README +14 -0
  34. data/ext/sparsehash-1.5.2/experimental/example.c +54 -0
  35. data/ext/sparsehash-1.5.2/experimental/libchash.c +1537 -0
  36. data/ext/sparsehash-1.5.2/experimental/libchash.h +252 -0
  37. data/ext/sparsehash-1.5.2/google-sparsehash.sln +47 -0
  38. data/ext/sparsehash-1.5.2/install-sh +323 -0
  39. data/ext/sparsehash-1.5.2/m4/acx_pthread.m4 +363 -0
  40. data/ext/sparsehash-1.5.2/m4/google_namespace.m4 +42 -0
  41. data/ext/sparsehash-1.5.2/m4/namespaces.m4 +15 -0
  42. data/ext/sparsehash-1.5.2/m4/stl_hash.m4 +70 -0
  43. data/ext/sparsehash-1.5.2/m4/stl_hash_fun.m4 +36 -0
  44. data/ext/sparsehash-1.5.2/m4/stl_namespace.m4 +25 -0
  45. data/ext/sparsehash-1.5.2/missing +360 -0
  46. data/ext/sparsehash-1.5.2/mkinstalldirs +158 -0
  47. data/ext/sparsehash-1.5.2/packages/deb.sh +74 -0
  48. data/ext/sparsehash-1.5.2/packages/deb/README +7 -0
  49. data/ext/sparsehash-1.5.2/packages/deb/changelog +107 -0
  50. data/ext/sparsehash-1.5.2/packages/deb/compat +1 -0
  51. data/ext/sparsehash-1.5.2/packages/deb/control +17 -0
  52. data/ext/sparsehash-1.5.2/packages/deb/copyright +35 -0
  53. data/ext/sparsehash-1.5.2/packages/deb/docs +16 -0
  54. data/ext/sparsehash-1.5.2/packages/deb/rules +117 -0
  55. data/ext/sparsehash-1.5.2/packages/deb/sparsehash.dirs +2 -0
  56. data/ext/sparsehash-1.5.2/packages/deb/sparsehash.install +2 -0
  57. data/ext/sparsehash-1.5.2/packages/rpm.sh +86 -0
  58. data/ext/sparsehash-1.5.2/packages/rpm/rpm.spec +61 -0
  59. data/ext/sparsehash-1.5.2/src/config.h.in +131 -0
  60. data/ext/sparsehash-1.5.2/src/config.h.include +23 -0
  61. data/ext/sparsehash-1.5.2/src/google/dense_hash_map +310 -0
  62. data/ext/sparsehash-1.5.2/src/google/dense_hash_set +287 -0
  63. data/ext/sparsehash-1.5.2/src/google/sparse_hash_map +294 -0
  64. data/ext/sparsehash-1.5.2/src/google/sparse_hash_set +275 -0
  65. data/ext/sparsehash-1.5.2/src/google/sparsehash/densehashtable.h +1062 -0
  66. data/ext/sparsehash-1.5.2/src/google/sparsehash/sparsehashtable.h +1015 -0
  67. data/ext/sparsehash-1.5.2/src/google/sparsetable +1468 -0
  68. data/ext/sparsehash-1.5.2/src/google/type_traits.h +250 -0
  69. data/ext/sparsehash-1.5.2/src/hashtable_unittest.cc +1375 -0
  70. data/ext/sparsehash-1.5.2/src/simple_test.cc +103 -0
  71. data/ext/sparsehash-1.5.2/src/sparsetable_unittest.cc +696 -0
  72. data/ext/sparsehash-1.5.2/src/time_hash_map.cc +488 -0
  73. data/ext/sparsehash-1.5.2/src/type_traits_unittest.cc +492 -0
  74. data/ext/sparsehash-1.5.2/src/windows/config.h +149 -0
  75. data/ext/sparsehash-1.5.2/src/windows/google/sparsehash/sparseconfig.h +32 -0
  76. data/ext/sparsehash-1.5.2/src/windows/port.cc +63 -0
  77. data/ext/sparsehash-1.5.2/src/windows/port.h +81 -0
  78. data/ext/sparsehash-1.5.2/src/words +8944 -0
  79. data/ext/sparsehash-1.5.2/vsprojects/hashtable_unittest/hashtable_unittest.vcproj +187 -0
  80. data/ext/sparsehash-1.5.2/vsprojects/sparsetable_unittest/sparsetable_unittest.vcproj +172 -0
  81. data/ext/sparsehash-1.5.2/vsprojects/time_hash_map/time_hash_map.vcproj +187 -0
  82. data/ext/sparsehash-1.5.2/vsprojects/type_traits_unittest/type_traits_unittest.vcproj +169 -0
  83. data/ext/test.rb +10 -0
  84. data/test/spec.go +70 -0
  85. metadata +147 -0
data/ext/sparsehash-1.5.2/doc/index.html ADDED
@@ -0,0 +1,69 @@
1
+ <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
2
+ <html>
3
+ <head>
4
+ <title>Google Sparsehash Package</title>
5
+
6
+ <meta http-equiv="Content-Type" content="text/html; charset=utf-8">
7
+ <link href="http://www.google.com/favicon.ico" type="image/x-icon"
8
+ rel="shortcut icon">
9
+ <link href="designstyle.css" type="text/css" rel="stylesheet">
10
+ <style>
11
+ <!--
12
+ ol.bluelist li {
13
+ color: #3366ff;
14
+ font-family: sans-serif;
15
+ }
16
+ ol.bluelist li p {
17
+ color: #000;
18
+ font-family: "Times Roman", times, serif;
19
+ }
20
+ ul.blacklist li {
21
+ color: #000;
22
+ font-family: "Times Roman", times, serif;
23
+ }
24
+ //-->
25
+ </style>
26
+ </head>
27
+ <body>
28
+
29
+ <h1> <a name="Google_Sparsehash_Package"></a>Google Sparsehash Package </h1>
30
+ <br>
31
+
32
+ <p>The Google sparsehash package consists of two hashtable
33
+ implementations: <i>sparse</i>, which is designed to be very space
34
+ efficient, and <i>dense</i>, which is designed to be very time
35
+ efficient. For each one, the package provides both a hash-map and a
36
+ hash-set, to mirror the classes in the common STL implementation.</p>
37
+
38
+ <p>Documentation on how to use these classes:</p>
39
+ <ul>
40
+ <li> <A HREF="sparse_hash_map.html">sparse_hash_map</A>
41
+ <li> <A HREF="sparse_hash_set.html">sparse_hash_set</A>
42
+ <li> <A HREF="dense_hash_map.html">dense_hash_map</A>
43
+ <li> <A HREF="dense_hash_set.html">dense_hash_set</A>
44
+ </ul>
45
+
46
+ <p>In addition to the hash-map (and hash-set) classes, there's also a
47
+ lower-level class that implements a "sparse" array. This class can be
48
+ useful in its own right; consider using it when you'd normally use a
49
+ <code>sparse_hash_map</code>, but your keys are all small-ish
50
+ integers.</p>
51
+ <ul>
52
+ <li> <A HREF="sparsetable.html">sparsetable</A>
53
+ </ul>
54
+
55
+ <p>There is also a doc explaining the <A
56
+ HREF="implementation.html">implementation details</A> of these
57
+ classes, for those who are curious. And finally, you can see some
58
+ <A HREF="performance.html">performance comparisons</A>, both between
59
+ the various classes here, but also between these implementations and
60
+ other standard hashtable implementations.</p>
61
+
62
+ <hr>
63
+ <address>
64
+ Craig Silverstein<br>
65
+ Last modified: Thu Jan 25 17:58:02 PST 2007
66
+ </address>
67
+
68
+ </body>
69
+ </html>
data/ext/sparsehash-1.5.2/doc/performance.html ADDED
@@ -0,0 +1,96 @@
1
+ <HTML>
2
+
3
+ <HEAD>
4
+ <title>Performance notes: sparse_hash, dense_hash, sparsetable</title>
5
+ </HEAD>
6
+
7
+ <BODY>
8
+
9
+ <H2>Performance Numbers</H2>
10
+
11
+ <p>Here are some performance numbers from an example desktop machine,
12
+ taken from a version of time_hash_map that was instrumented to also
13
+ report memory allocation information (this modification is not
14
+ included by default because it required a big hack to do, including
15
+ modifying the STL code to not try to do its own freelist management).</p>
16
+
17
+ <p>Note there are lots of caveats on these numbers: they may differ from
18
+ machine to machine and compiler to compiler, and they only test a very
19
+ particular usage pattern that may not match how you use hashtables --
20
+ for instance, they test hashtables with very small keys. However,
21
+ they're still useful for a baseline comparison of the various
22
+ hashtable implementations.</p>
23
+
24
+ <p>These figures are from a 2.80GHz Pentium 4 with 2G of memory. The
25
+ 'standard' hash_map and map implementations are the SGI STL code
26
+ included with <tt>gcc2</tt>. Compiled with <tt>gcc2.95.3 -g
27
+ -O2</tt></p>
28
+
29
+ <pre>
30
+ ======
31
+ Average over 10000000 iterations
32
+ Wed Dec 8 14:56:38 PST 2004
33
+
34
+ SPARSE_HASH_MAP:
35
+ map_grow 665 ns
36
+ map_predict/grow 303 ns
37
+ map_replace 177 ns
38
+ map_fetch 117 ns
39
+ map_remove 192 ns
40
+ memory used in map_grow 84.3956 Mbytes
41
+
42
+ DENSE_HASH_MAP:
43
+ map_grow 84 ns
44
+ map_predict/grow 22 ns
45
+ map_replace 18 ns
46
+ map_fetch 13 ns
47
+ map_remove 23 ns
48
+ memory used in map_grow 256.0000 Mbytes
49
+
50
+ STANDARD HASH_MAP:
51
+ map_grow 162 ns
52
+ map_predict/grow 107 ns
53
+ map_replace 44 ns
54
+ map_fetch 22 ns
55
+ map_remove 124 ns
56
+ memory used in map_grow 204.1643 Mbytes
57
+
58
+ STANDARD MAP:
59
+ map_grow 297 ns
60
+ map_predict/grow 282 ns
61
+ map_replace 113 ns
62
+ map_fetch 113 ns
63
+ map_remove 238 ns
64
+ memory used in map_grow 236.8081 Mbytes
65
+ </pre>
66
+
67
+
68
+ <H2><A name="hashfn">A Note on Hash Functions</A></H2>
69
+
70
+ <p>For good performance, the Google hash routines depend on a good
71
+ hash function: one that distributes data evenly. Many hashtable
72
+ implementations come with sub-optimal hash functions that can degrade
73
+ performance. For instance, the hash function given in Knuth's _Art of
74
+ Computer Programming_, and the default string hash function in SGI's
75
+ STL implementation, both distribute certain data sets unevenly,
76
+ leading to poor performance.</p>
77
+
78
+ <p>As an example, in one test of the default SGI STL string hash
79
+ function against the Hsieh hash function (see below), for a particular
80
+ set of string keys, the Hsieh function resulted in hashtable lookups
81
+ that were 20 times as fast as the STLPort hash function. The string
82
+ keys were chosen to be "hard" to hash well, so these results may not
83
+ be typical, but they are suggestive.</p>
84
+
85
+ <p>There has been much research over the years into good hash
86
+ functions. Here are some hash functions of note.</p>
87
+
88
+ <ul>
89
+ <li> Bob Jenkins: <A HREF="http://burtleburtle.net/bob/hash/">http://burtleburtle.net/bob/hash/</A>
90
+ <li> Paul Hsieh: <A HREF="http://www.azillionmonkeys.com/qed/hash.html">http://www.azillionmonkeys.com/qed/hash.html</A>
91
+ <li> Fowler/Noll/Vo (FNV): <A HREF="http://www.isthe.com/chongo/tech/comp/fnv/">http://www.isthe.com/chongo/tech/comp/fnv/</A>
92
+ <li> MurmurHash: <A HREF="http://murmurhash.googlepages.com/">http://murmurhash.googlepages.com/</A>
93
+ </ul>
94
+
95
+ </body>
96
+ </html>
data/ext/sparsehash-1.5.2/doc/sparse_hash_map.html ADDED
@@ -0,0 +1,1527 @@
1
+ <HTML>
2
+ <!-- The API of this class and the documentation -- but not the
3
+ implementation! -- are based on that for SGI's hash_map class,
4
+ augmented with tr1 support.
5
+ -->
6
+ <!--
7
+ -- Copyright (c) 1996-1999
8
+ -- Silicon Graphics Computer Systems, Inc.
9
+ --
10
+ -- Permission to use, copy, modify, distribute and sell this software
11
+ -- and its documentation for any purpose is hereby granted without fee,
12
+ -- provided that the above copyright notice appears in all copies and
13
+ -- that both that copyright notice and this permission notice appear
14
+ -- in supporting documentation. Silicon Graphics makes no
15
+ -- representations about the suitability of this software for any
16
+ -- purpose. It is provided "as is" without express or implied warranty.
17
+ --
18
+ -- Copyright (c) 1994
19
+ -- Hewlett-Packard Company
20
+ --
21
+ -- Permission to use, copy, modify, distribute and sell this software
22
+ -- and its documentation for any purpose is hereby granted without fee,
23
+ -- provided that the above copyright notice appears in all copies and
24
+ -- that both that copyright notice and this permission notice appear
25
+ -- in supporting documentation. Hewlett-Packard Company makes no
26
+ -- representations about the suitability of this software for any
27
+ -- purpose. It is provided "as is" without express or implied warranty.
28
+ --
29
+ -->
30
+
31
+ <HEAD>
32
+ <Title>sparse_hash_map&lt;Key, Data, HashFcn, EqualKey, Alloc&gt;</Title>
33
+ </HEAD>
34
+
35
+ <BODY>
36
+
37
+ <p><i>[Note: this document is formatted similarly to the SGI STL
38
+ implementation documentation pages, and refers to concepts and classes
39
+ defined there. However, neither this document nor the code it
40
+ describes is associated with SGI, nor is it necessary to have SGI's
41
+ STL implementation installed in order to use this class.]</i></p>
42
+
43
+
44
+ <H1>sparse_hash_map&lt;Key, Data, HashFcn, EqualKey, Alloc&gt;</H1>
45
+
46
+ <p><tt>sparse_hash_map</tt> is a <A
47
+ href="http://www.sgi.com/tech/stl/HashedAssociativeContainer.html">Hashed
48
+ Associative Container</A> that associates objects of type <tt>Key</tt>
49
+ with objects of type <tt>Data</tt>. <tt>sparse_hash_map</tt> is a <A
50
+ href="http://www.sgi.com/tech/stl/PairAssociativeContainer.html">Pair
51
+ Associative Container</A>, meaning that its value type is <tt><A
52
+ href="pair.html">pair</A>&lt;const Key, Data&gt;</tt>. It is also a
53
+ <A
54
+ href="http://www.sgi.com/tech/stl/UniqueAssociativeContainer.html">Unique
55
+ Associative Container</A>, meaning that no two elements have keys that
56
+ compare equal using <tt>EqualKey</tt>.</p>
57
+
58
+ <p>Looking up an element in a <tt>sparse_hash_map</tt> by its key is
59
+ efficient, so <tt>sparse_hash_map</tt> is useful for &quot;dictionaries&quot;
60
+ where the order of elements is irrelevant. If it is important for the
61
+ elements to be in a particular order, however, then <tt><A
62
+ href="http://www.sgi.com/tech/stl/Map.html">map</A></tt> is more appropriate.</p>
63
+
64
+ <p><tt>sparse_hash_map</tt> is distinguished from other hash-map
65
+ implementations by its stingy use of memory and by the ability to save
66
+ and restore contents to disk. On the other hand, this hash-map
67
+ implementation, while still efficient, is slower than other hash-map
68
+ implementations, and it also has requirements -- for instance, for a
69
+ distinguished "deleted key" -- that may not be easy for all
70
+ applications to satisfy.</p>
71
+
72
+ <p>This class is appropriate for applications that need to store
73
+ large "dictionaries" in memory, or for applications that need these
74
+ dictionaries to be persistent.</p>
75
+
76
+
77
+ <h3>Example</h3>
78
+
79
+ (Note: this example uses SGI semantics for <code>hash&lt;&gt;</code>
80
+ -- the kind used by gcc and most Unix compiler suites -- and not
81
+ Dinkumware semantics -- the kind used by Microsoft Visual Studio. If
82
+ you are using MSVC, this example will not compile as-is: you'll need
83
+ to change <code>hash</code> to <code>hash_compare</code>, and you
84
+ won't use <code>eqstr</code> at all. See the MSVC documentation for
85
+ <code>hash_map</code> and <code>hash_compare</code>, for more
86
+ details.)
87
+
88
+ <pre>
89
+ #include &lt;iostream&gt;
90
+ #include &lt;google/sparse_hash_map&gt;
91
+
92
+ using google::sparse_hash_map; // namespace where class lives by default
93
+ using std::cout;
94
+ using std::endl;
95
+ using ext::hash; // or __gnu_cxx::hash, or maybe tr1::hash, depending on your OS
96
+
97
+ struct eqstr
98
+ {
99
+ bool operator()(const char* s1, const char* s2) const
100
+ {
101
+ return (s1 == s2) || (s1 && s2 && strcmp(s1, s2) == 0);
102
+ }
103
+ };
104
+
105
+ int main()
106
+ {
107
+ sparse_hash_map&lt;const char*, int, hash&lt;const char*&gt;, eqstr&gt; months;
108
+
109
+ months[&quot;january&quot;] = 31;
110
+ months[&quot;february&quot;] = 28;
111
+ months[&quot;march&quot;] = 31;
112
+ months[&quot;april&quot;] = 30;
113
+ months[&quot;may&quot;] = 31;
114
+ months[&quot;june&quot;] = 30;
115
+ months[&quot;july&quot;] = 31;
116
+ months[&quot;august&quot;] = 31;
117
+ months[&quot;september&quot;] = 30;
118
+ months[&quot;october&quot;] = 31;
119
+ months[&quot;november&quot;] = 30;
120
+ months[&quot;december&quot;] = 31;
121
+
122
+ cout &lt;&lt; &quot;september -&gt; &quot; &lt;&lt; months[&quot;september&quot;] &lt;&lt; endl;
123
+ cout &lt;&lt; &quot;april -&gt; &quot; &lt;&lt; months[&quot;april&quot;] &lt;&lt; endl;
124
+ cout &lt;&lt; &quot;june -&gt; &quot; &lt;&lt; months[&quot;june&quot;] &lt;&lt; endl;
125
+ cout &lt;&lt; &quot;november -&gt; &quot; &lt;&lt; months[&quot;november&quot;] &lt;&lt; endl;
126
+ }
127
+ </pre>
128
+
129
+
130
+ <h3>Definition</h3>
131
+
132
+ Defined in the header <A href="sparse_hash_map">sparse_hash_map</A>.
133
+ This class is not part of the C++ standard, though it is mostly
134
+ compatible with the tr1 class <code>unordered_map</code>.
135
+
136
+
137
+ <h3>Template parameters</h3>
138
+
139
+ <table border>
140
+ <TR><TH>Parameter</TH><TH>Description</TH><TH>Default</TH></TR>
141
+
142
+ <TR>
143
+ <TD VAlign=top>
144
+ <tt>Key</tt>
145
+ </TD>
146
+ <TD VAlign=top>
147
+ The hash_map's key type. This is also defined as
148
+ <tt>sparse_hash_map::key_type</tt>.
149
+ </TD>
150
+ <TD VAlign=top>
151
+ &nbsp;
152
+ </TD>
153
+ </TR>
154
+
155
+ <TR>
156
+ <TD VAlign=top>
157
+ <tt>Data</tt>
158
+ </TD>
159
+ <TD VAlign=top>
160
+ The hash_map's data type. This is also defined as
161
+ <tt>sparse_hash_map::data_type</tt>.
162
+ </TD>
163
+ <TD VAlign=top>
164
+ &nbsp;
165
+ </TD>
166
+ </TR>
167
+
168
+ <TR>
169
+ <TD VAlign=top>
170
+ <tt>HashFcn</tt>
171
+ </TD>
172
+ <TD VAlign=top>
173
+ The <A href="http://www.sgi.com/tech/stl/HashFunction.html">hash function</A> used by the
174
+ hash_map. This is also defined as <tt>sparse_hash_map::hasher</tt>.
175
+ <br><b>Note:</b> Hashtable performance depends heavliy on the choice of
176
+ hash function. See <A HREF="performance.html#hashfn">the performance
177
+ page</A> for more information.
178
+ </TD>
179
+ <TD VAlign=top>
180
+ <tt><A href="http://www.sgi.com/tech/stl/hash.html">hash</A>&lt;Key&gt;</tt>
181
+ </TD>
182
+ </TR>
183
+
184
+ <TR>
185
+ <TD VAlign=top>
186
+ <tt>EqualKey</tt>
187
+ </TD>
188
+ <TD VAlign=top>
189
+ The hash_map key equality function: a <A
190
+ href="http://www.sgi.com/tech/stl/BinaryPredicate.html">binary predicate</A> that determines
191
+ whether two keys are equal. This is also defined as
192
+ <tt>sparse_hash_map::key_equal</tt>.
193
+ </TD>
194
+ <TD VAlign=top>
195
+ <tt><A href="http://www.sgi.com/tech/stl/equal_to.html">equal_to</A>&lt;Key&gt;</tt>
196
+ </TD>
197
+ </TR>
198
+
199
+ <TR>
200
+ <TD VAlign=top>
201
+ <tt>Alloc</tt>
202
+ </TD>
203
+ <TD VAlign=top>
204
+ <b>Ignored</b>; this is included only for API-compatibility
205
+ with SGI's (and tr1's) STL implementation.
206
+ </TD>
207
+ <TD VAlign=top>
208
+ </TD>
209
+ </TR>
210
+
211
+ </table>
212
+
213
+
214
+ <h3>Model of</h3>
215
+
216
+ <A href="http://www.sgi.com/tech/stl/UniqueHashedAssociativeContainer.html">Unique Hashed Associative Container</A>,
217
+ <A href="http://www.sgi.com/tech/stl/PairAssociativeContainer.html">Pair Associative Container</A>
218
+
219
+
220
+ <h3>Type requirements</h3>
221
+
222
+ <UL>
223
+ <LI>
224
+ <tt>Key</tt> is Assignable.
225
+ <LI>
226
+ <tt>EqualKey</tt> is a Binary Predicate whose argument type is Key.
227
+ <LI>
228
+ <tt>EqualKey</tt> is an equivalence relation.
229
+ <LI>
230
+ <tt>Alloc</tt> is an Allocator.
231
+ </UL>
232
+
233
+
234
+ <h3>Public base classes</h3>
235
+
236
+ None.
237
+
238
+
239
+ <h3>Members</h3>
240
+
241
+ <table border>
242
+ <TR><TH>Member</TH><TH>Where defined</TH><TH>Description</TH></TR>
243
+
244
+ <TR>
245
+ <TD VAlign=top>
246
+ <tt>key_type</tt>
247
+ </TD>
248
+ <TD VAlign=top>
249
+ <A
250
+ href="http://www.sgi.com/tech/stl/AssociativeContainer.html">Associative
251
+ Container</A>
252
+ </TD>
253
+ <TD VAlign=top>
254
+ The <tt>sparse_hash_map</tt>'s key type, <tt>Key</tt>.
255
+ </TD>
256
+ </TR>
257
+
258
+ <TR>
259
+ <TD VAlign=top>
260
+ <tt>data_type</tt>
261
+ </TD>
262
+ <TD VAlign=top>
263
+ <A
264
+ href="http://www.sgi.com/tech/stl/PairAssociativeContainer.html">Pair
265
+ Associative Container</A>
266
+ </TD>
267
+ <TD VAlign=top>
268
+ The type of object associated with the keys.
269
+ </TD>
270
+ </TR>
271
+
272
+ <TR>
273
+ <TD VAlign=top>
274
+ <tt>value_type</tt>
275
+ </TD>
276
+ <TD VAlign=top>
277
+ <A
278
+ href="http://www.sgi.com/tech/stl/PairAssociativeContainer.html">Pair
279
+ Associative Container</A>
280
+ </TD>
281
+ <TD VAlign=top>
282
+ The type of object, <tt>pair&lt;const key_type, data_type&gt;</tt>,
283
+ stored in the hash_map.
284
+ </TD>
285
+ </TR>
286
+
287
+ <TR>
288
+ <TD VAlign=top>
289
+ <tt>hasher</tt>
290
+ </TD>
291
+ <TD VAlign=top>
292
+ <A
293
+ href="http://www.sgi.com/tech/stl/HashedAssociativeContainer.html">Hashed
294
+ Associative Container</A>
295
+ </TD>
296
+ <TD VAlign=top>
297
+ The <tt>sparse_hash_map</tt>'s <A
298
+ href="http://www.sgi.com/tech/stl/HashFunction.html">hash
299
+ function</A>.
300
+ </TD>
301
+ </TR>
302
+
303
+ <TR>
304
+ <TD VAlign=top>
305
+ <tt>key_equal</tt>
306
+ </TD>
307
+ <TD VAlign=top>
308
+ <A
309
+ href="http://www.sgi.com/tech/stl/HashedAssociativeContainer.html">Hashed
310
+ Associative Container</A>
311
+ </TD>
312
+ <TD VAlign=top>
313
+ <A href="http://www.sgi.com/tech/stl/functors.html">Function
314
+ object</A> that compares keys for equality.
315
+ </TD>
316
+ </TR>
317
+
318
+ <TR>
319
+ <TD VAlign=top>
320
+ <tt>allocator_type</tt>
321
+ </TD>
322
+ <TD VAlign=top>
323
+ <tt>Unordered Associative Container</tt> (tr1)
324
+ </TD>
325
+ <TD VAlign=top>
326
+ The type of the Allocator given as a template parameter.
327
+ </TD>
328
+ </TR>
329
+
330
+ <TR>
331
+ <TD VAlign=top>
332
+ <tt>pointer</tt>
333
+ </TD>
334
+ <TD VAlign=top>
335
+ <A href="http://www.sgi.com/tech/stl/Container.html">Container</A>
336
+ </TD>
337
+ <TD VAlign=top>
338
+ Pointer to <tt>T</tt>.
339
+ </TD>
340
+ </TR>
341
+
342
+ <TR>
343
+ <TD VAlign=top>
344
+ <tt>reference</tt>
345
+ </TD>
346
+ <TD VAlign=top>
347
+ <A href="http://www.sgi.com/tech/stl/Container.html">Container</A>
348
+ </TD>
349
+ <TD VAlign=top>
350
+ Reference to <tt>T</tt>
351
+ </TD>
352
+ </TR>
353
+
354
+ <TR>
355
+ <TD VAlign=top>
356
+ <tt>const_reference</tt>
357
+ </TD>
358
+ <TD VAlign=top>
359
+ <A href="http://www.sgi.com/tech/stl/Container.html">Container</A>
360
+ </TD>
361
+ <TD VAlign=top>
362
+ Const reference to <tt>T</tt>
363
+ </TD>
364
+ </TR>
365
+
366
+ <TR>
367
+ <TD VAlign=top>
368
+ <tt>size_type</tt>
369
+ </TD>
370
+ <TD VAlign=top>
371
+ <A href="http://www.sgi.com/tech/stl/Container.html">Container</A>
372
+ </TD>
373
+ <TD VAlign=top>
374
+ An unsigned integral type.
375
+ </TD>
376
+ </TR>
377
+
378
+ <TR>
379
+ <TD VAlign=top>
380
+ <tt>difference_type</tt>
381
+ </TD>
382
+ <TD VAlign=top>
383
+ <A href="http://www.sgi.com/tech/stl/Container.html">Container</A>
384
+ </TD>
385
+ <TD VAlign=top>
386
+ A signed integral type.
387
+ </TD>
388
+ </TR>
389
+
390
+ <TR>
391
+ <TD VAlign=top>
392
+ <tt>iterator</tt>
393
+ </TD>
394
+ <TD VAlign=top>
395
+ <A href="http://www.sgi.com/tech/stl/Container.html">Container</A>
396
+ </TD>
397
+ <TD VAlign=top>
398
+ Iterator used to iterate through a <tt>sparse_hash_map</tt>. <A
399
+ href="#1">[1]</A>
400
+ </TD>
401
+ </TR>
402
+
403
+ <TR>
404
+ <TD VAlign=top>
405
+ <tt>const_iterator</tt>
406
+ </TD>
407
+ <TD VAlign=top>
408
+ <A href="http://www.sgi.com/tech/stl/Container.html">Container</A>
409
+ </TD>
410
+ <TD VAlign=top>
411
+ Const iterator used to iterate through a <tt>sparse_hash_map</tt>.
412
+ </TD>
413
+ </TR>
414
+
415
+ <TR>
416
+ <TD VAlign=top>
417
+ <tt>local_iterator</tt>
418
+ </TD>
419
+ <TD VAlign=top>
420
+ <tt>Unordered Associative Container</tt> (tr1)
421
+ </TD>
422
+ <TD VAlign=top>
423
+ Iterator used to iterate through a subset of
424
+ <tt>sparse_hash_map</tt>. <A href="#1">[1]</A>
425
+ </TD>
426
+ </TR>
427
+
428
+ <TR>
429
+ <TD VAlign=top>
430
+ <tt>const_local_iterator</tt>
431
+ </TD>
432
+ <TD VAlign=top>
433
+ <tt>Unordered Associative Container</tt> (tr1)
434
+ </TD>
435
+ <TD VAlign=top>
436
+ Const iterator used to iterate through a subset of
437
+ <tt>sparse_hash_map</tt>.
438
+ </TD>
439
+ </TR>
440
+
441
+ <TR>
442
+ <TD VAlign=top>
443
+ <tt>iterator begin()</tt>
444
+ </TD>
445
+ <TD VAlign=top>
446
+ <A href="http://www.sgi.com/tech/stl/Container.html">Container</A>
447
+ </TD>
448
+ <TD VAlign=top>
449
+ Returns an <tt>iterator</tt> pointing to the beginning of the
450
+ <tt>sparse_hash_map</tt>.
451
+ </TD>
452
+ </TR>
453
+
454
+ <TR>
455
+ <TD VAlign=top>
456
+ <tt>iterator end()</tt>
457
+ </TD>
458
+ <TD VAlign=top>
459
+ <A href="http://www.sgi.com/tech/stl/Container.html">Container</A>
460
+ </TD>
461
+ <TD VAlign=top>
462
+ Returns an <tt>iterator</tt> pointing to the end of the
463
+ <tt>sparse_hash_map</tt>.
464
+ </TD>
465
+ </TR>
466
+
467
+ <TR>
468
+ <TD VAlign=top>
469
+ <tt>const_iterator begin() const</tt>
470
+ </TD>
471
+ <TD VAlign=top>
472
+ <A href="http://www.sgi.com/tech/stl/Container.html">Container</A>
473
+ </TD>
474
+ <TD VAlign=top>
475
+ Returns an <tt>const_iterator</tt> pointing to the beginning of the
476
+ <tt>sparse_hash_map</tt>.
477
+ </TD>
478
+ </TR>
479
+
480
+ <TR>
481
+ <TD VAlign=top>
482
+ <tt>const_iterator end() const</tt>
483
+ </TD>
484
+ <TD VAlign=top>
485
+ <A href="http://www.sgi.com/tech/stl/Container.html">Container</A>
486
+ </TD>
487
+ <TD VAlign=top>
488
+ Returns an <tt>const_iterator</tt> pointing to the end of the
489
+ <tt>sparse_hash_map</tt>.
490
+ </TD>
491
+ </TR>
492
+
493
+ <TR>
494
+ <TD VAlign=top>
495
+ <tt>local_iterator begin(size_type i)</tt>
496
+ </TD>
497
+ <TD VAlign=top>
498
+ <tt>Unordered Associative Container</tt> (tr1)
499
+ </TD>
500
+ <TD VAlign=top>
501
+ Returns a <tt>local_iterator</tt> pointing to the beginning of bucket
502
+ <tt>i</tt> in the <tt>sparse_hash_map</tt>.
503
+ </TD>
504
+ </TR>
505
+
506
+ <TR>
507
+ <TD VAlign=top>
508
+ <tt>local_iterator end(size_type i)</tt>
509
+ </TD>
510
+ <TD VAlign=top>
511
+ <tt>Unordered Associative Container</tt> (tr1)
512
+ </TD>
513
+ <TD VAlign=top>
514
+ Returns a <tt>local_iterator</tt> pointing to the end of bucket
515
+ <tt>i</tt> in the <tt>sparse_hash_map</tt>. For
516
+ <tt>sparse_hash_map</tt>, each bucket contains either 0 or 1 item.
517
+ </TD>
518
+ </TR>
519
+
520
+ <TR>
521
+ <TD VAlign=top>
522
+ <tt>const_local_iterator begin(size_type i) const</tt>
523
+ </TD>
524
+ <TD VAlign=top>
525
+ <tt>Unordered Associative Container</tt> (tr1)
526
+ </TD>
527
+ <TD VAlign=top>
528
+ Returns a <tt>const_local_iterator</tt> pointing to the beginning of bucket
529
+ <tt>i</tt> in the <tt>sparse_hash_map</tt>.
530
+ </TD>
531
+ </TR>
532
+
533
+ <TR>
534
+ <TD VAlign=top>
535
+ <tt>const_local_iterator end(size_type i) const</tt>
536
+ </TD>
537
+ <TD VAlign=top>
538
+ <tt>Unordered Associative Container</tt> (tr1)
539
+ </TD>
540
+ <TD VAlign=top>
541
+ Returns a <tt>const_local_iterator</tt> pointing to the end of bucket
542
+ <tt>i</tt> in the <tt>sparse_hash_map</tt>. For
543
+ <tt>sparse_hash_map</tt>, each bucket contains either 0 or 1 item.
544
+ </TD>
545
+ </TR>
546
+
547
+ <TR>
548
+ <TD VAlign=top>
549
+ <tt>size_type size() const</tt>
550
+ </TD>
551
+ <TD VAlign=top>
552
+ <A href="http://www.sgi.com/tech/stl/Container.html">Container</A>
553
+ </TD>
554
+ <TD VAlign=top>
555
+ Returns the size of the <tt>sparse_hash_map</tt>.
556
+ </TD>
557
+ </TR>
558
+
559
+ <TR>
560
+ <TD VAlign=top>
561
+ <tt>size_type max_size() const</tt>
562
+ </TD>
563
+ <TD VAlign=top>
564
+ <A href="http://www.sgi.com/tech/stl/Container.html">Container</A>
565
+ </TD>
566
+ <TD VAlign=top>
567
+ Returns the largest possible size of the <tt>sparse_hash_map</tt>.
568
+ </TD>
569
+ </TR>
570
+
571
+ <TR>
572
+ <TD VAlign=top>
573
+ <tt>bool empty() const</tt>
574
+ </TD>
575
+ <TD VAlign=top>
576
+ <A href="http://www.sgi.com/tech/stl/Container.html">Container</A>
577
+ </TD>
578
+ <TD VAlign=top>
579
+ <tt>true</tt> if the <tt>sparse_hash_map</tt>'s size is <tt>0</tt>.
580
+ </TD>
581
+ </TR>
582
+
583
+ <TR>
584
+ <TD VAlign=top>
585
+ <tt>size_type bucket_count() const</tt>
586
+ </TD>
587
+ <TD VAlign=top>
588
+ <A
589
+ href="http://www.sgi.com/tech/stl/HashedAssociativeContainer.html">Hashed
590
+ Associative Container</A>
591
+ </TD>
592
+ <TD VAlign=top>
593
+ Returns the number of buckets used by the <tt>sparse_hash_map</tt>.
594
+ </TD>
595
+ </TR>
596
+
597
+ <TR>
598
+ <TD VAlign=top>
599
+ <tt>size_type max_bucket_count() const</tt>
600
+ </TD>
601
+ <TD VAlign=top>
602
+ <A
603
+ href="http://www.sgi.com/tech/stl/HashedAssociativeContainer.html">Hashed
604
+ Associative Container</A>
605
+ </TD>
606
+ <TD VAlign=top>
607
+ Returns the largest possible number of buckets used by the <tt>sparse_hash_map</tt>.
608
+ </TD>
609
+ </TR>
610
+
611
+ <TR>
612
+ <TD VAlign=top>
613
+ <tt>size_type bucket_size(size_type i) const</tt>
614
+ </TD>
615
+ <TD VAlign=top>
616
+ <tt>Unordered Associative Container</tt> (tr1)
617
+ </TD>
618
+ <TD VAlign=top>
619
+ Returns the number of elements in bucket <tt>i</tt>. For
620
+ <tt>sparse_hash_map</tt>, this will be either 0 or 1.
621
+ </TD>
622
+ </TR>
623
+
624
+ <TR>
625
+ <TD VAlign=top>
626
+ <tt>size_type bucket(const key_type& key) const</tt>
627
+ </TD>
628
+ <TD VAlign=top>
629
+ <tt>Unordered Associative Container</tt> (tr1)
630
+ </TD>
631
+ <TD VAlign=top>
632
+ If the key exists in the map, returns the index of the bucket
633
+ containing the given key, otherwise, return the bucket the key
634
+ would be inserted into.
635
+ This value may be passed to <tt>begin(size_type)</tt> and
636
+ <tt>end(size_type)</tt>.
637
+ </TD>
638
+ </TR>
639
+
640
+ <TR>
641
+ <TD VAlign=top>
642
+ <tt>float load_factor() const</tt>
643
+ </TD>
644
+ <TD VAlign=top>
645
+ <tt>Unordered Associative Container</tt> (tr1)
646
+ </TD>
647
+ <TD VAlign=top>
648
+ The number of elements in the <tt>sparse_hash_map</tt> divided by
649
+ the number of buckets.
650
+ </TD>
651
+ </TR>
652
+
653
+ <TR>
654
+ <TD VAlign=top>
655
+ <tt>float max_load_factor() const</tt>
656
+ </TD>
657
+ <TD VAlign=top>
658
+ <tt>Unordered Associative Container</tt> (tr1)
659
+ </TD>
660
+ <TD VAlign=top>
661
+ The maximum load factor before increasing the number of buckets in
662
+ the <tt>sparse_hash_map</tt>.
663
+ </TD>
664
+ </TR>
665
+
666
+ <TR>
667
+ <TD VAlign=top>
668
+ <tt>float max_load_factor(size_t new_grow)</tt>
669
+ </TD>
670
+ <TD VAlign=top>
671
+ <tt>Unordered Associative Container</tt> (tr1)
672
+ </TD>
673
+ <TD VAlign=top>
674
+ Sets the maximum load factor before increasing the number of
675
+ buckets in the <tt>sparse_hash_map</tt>.
676
+ </TD>
677
+ </TR>
678
+
679
+ <TR>
680
+ <TD VAlign=top>
681
+ <tt>float min_load_factor() const</tt>
682
+ </TD>
683
+ <TD VAlign=top>
684
+ <tt>sparse_hash_map</tt>
685
+ </TD>
686
+ <TD VAlign=top>
687
+ The minimum load factor before decreasing the number of buckets in
688
+ the <tt>sparse_hash_map</tt>.
689
+ </TD>
690
+ </TR>
691
+
692
+ <TR>
693
+ <TD VAlign=top>
694
+ <tt>float min_load_factor(size_t new_grow)</tt>
695
+ </TD>
696
+ <TD VAlign=top>
697
+ <tt>sparse_hash_map</tt>
698
+ </TD>
699
+ <TD VAlign=top>
700
+ Sets the minimum load factor before decreasing the number of
701
+ buckets in the <tt>sparse_hash_map</tt>.
702
+ </TD>
703
+ </TR>
704
+
705
+ <TR>
706
+ <TD VAlign=top>
707
+ <tt>void set_resizing_parameters(float shrink, float grow)</tt>
708
+ </TD>
709
+ <TD VAlign=top>
710
+ <tt>sparse_hash_map</tt>
711
+ </TD>
712
+ <TD VAlign=top>
713
+ DEPRECATED. <A HREF="#new">See below</A>.
714
+ </TD>
715
+ </TR>
716
+
717
+ <TR>
718
+ <TD VAlign=top>
719
+ <tt>void resize(size_type n)</tt>
720
+ </TD>
721
+ <TD VAlign=top>
722
+ <A
723
+ href="http://www.sgi.com/tech/stl/HashedAssociativeContainer.html">Hashed
724
+ Associative Container</A>
725
+ </TD>
726
+ <TD VAlign=top>
727
+ Increases the bucket count to hold at least <tt>n</tt> items.
728
+ <A href="#4">[4]</A> <A href="#5">[5]</A>
729
+ </TD>
730
+ </TR>
731
+
732
+ <TR>
733
+ <TD VAlign=top>
734
+ <tt>void rehash(size_type n)</tt>
735
+ </TD>
736
+ <TD VAlign=top>
737
+ <tt>Unordered Associative Container</tt> (tr1)
738
+ </TD>
739
+ <TD VAlign=top>
740
+ Increases the bucket count to hold at least <tt>n</tt> items.
741
+ This is identical to <tt>resize</tt>.
742
+ <A href="#4">[4]</A> <A href="#5">[5]</A>
743
+ </TD>
744
+ </TR>
745
+
746
+ <TR>
747
+ <TD VAlign=top>
748
+ <tt>hasher hash_funct() const</tt>
749
+ </TD>
750
+ <TD VAlign=top>
751
+ <A
752
+ href="http://www.sgi.com/tech/stl/HashedAssociativeContainer.html">Hashed
753
+ Associative Container</A>
754
+ </TD>
755
+ <TD VAlign=top>
756
+ Returns the <tt>hasher</tt> object used by the <tt>sparse_hash_map</tt>.
757
+ </TD>
758
+ </TR>
759
+
760
+ <TR>
761
+ <TD VAlign=top>
762
+ <tt>hasher hash_function() const</tt>
763
+ </TD>
764
+ <TD VAlign=top>
765
+ <tt>Unordered Associative Container</tt> (tr1)
766
+ </TD>
767
+ <TD VAlign=top>
768
+ Returns the <tt>hasher</tt> object used by the <tt>sparse_hash_map</tt>.
769
+ This is idential to <tt>hash_funct</tt>.
770
+ </TD>
771
+ </TR>
772
+
773
+ <TR>
774
+ <TD VAlign=top>
775
+ <tt>key_equal key_eq() const</tt>
776
+ </TD>
777
+ <TD VAlign=top>
778
+ <A
779
+ href="http://www.sgi.com/tech/stl/HashedAssociativeContainer.html">Hashed
780
+ Associative Container</A>
781
+ </TD>
782
+ <TD VAlign=top>
783
+ Returns the <tt>key_equal</tt> object used by the
784
+ <tt>sparse_hash_map</tt>.
785
+ </TD>
786
+ </TR>
787
+
788
+ <TR>
789
+ <TD VAlign=top>
790
+ <tt>sparse_hash_map()</tt>
791
+ </TD>
792
+ <TD VAlign=top>
793
+ <A href="http://www.sgi.com/tech/stl/Container.html">Container</A>
794
+ </TD>
795
+ <TD VAlign=top>
796
+ Creates an empty <tt>sparse_hash_map</tt>.
797
+ </TD>
798
+ </TR>
799
+
800
+ <TR>
801
+ <TD VAlign=top>
802
+ <tt>sparse_hash_map(size_type n)</tt>
803
+ </TD>
804
+ <TD VAlign=top>
805
+ <A
806
+ href="http://www.sgi.com/tech/stl/HashedAssociativeContainer.html">Hashed
807
+ Associative Container</A>
808
+ </TD>
809
+ <TD VAlign=top>
810
+ Creates an empty <tt>sparse_hash_map</tt> that's optimized for holding
811
+ up to <tt>n</tt> items.
812
+ <A href="#5">[5]</A>
813
+ </TD>
814
+ </TR>
815
+
816
+ <TR>
817
+ <TD VAlign=top>
818
+ <tt>sparse_hash_map(size_type n, const hasher&amp; h)</tt>
819
+ </TD>
820
+ <TD VAlign=top>
821
+ <A
822
+ href="http://www.sgi.com/tech/stl/HashedAssociativeContainer.html">Hashed
823
+ Associative Container</A>
824
+ </TD>
825
+ <TD VAlign=top>
826
+ Creates an empty <tt>sparse_hash_map</tt> that's optimized for up
827
+ to <tt>n</tt> items, using <tt>h</tt> as the hash function.
828
+ </TD>
829
+ </TR>
830
+
831
+ <TR>
832
+ <TD VAlign=top>
833
+ <tt>sparse_hash_map(size_type n, const hasher&amp; h, const
834
+ key_equal&amp; k)</tt>
835
+ </TD>
836
+ <TD VAlign=top>
837
+ <A
838
+ href="http://www.sgi.com/tech/stl/HashedAssociativeContainer.html">Hashed
839
+ Associative Container</A>
840
+ </TD>
841
+ <TD VAlign=top>
842
+ Creates an empty <tt>sparse_hash_map</tt> that's optimized for up
843
+ to <tt>n</tt> items, using <tt>h</tt> as the hash function and
844
+ <tt>k</tt> as the key equal function.
845
+ </TD>
846
+ </TR>
847
+
848
+ <TR>
849
+ <TD VAlign=top>
850
+ <pre>template &lt;class <A
851
+ href="http://www.sgi.com/tech/stl/InputIterator.html">InputIterator</A>&gt;
852
+ sparse_hash_map(InputIterator f, InputIterator l) </pre>
853
+ <A href="#2">[2]</A>
854
+ </TD>
855
+ <TD VAlign=top>
856
+ <A
857
+ href="http://www.sgi.com/tech/stl/UniqueHashedAssociativeContainer.html">Unique
858
+ Hashed Associative Container</A>
859
+ </TD>
860
+ <TD VAlign=top>
861
+ Creates a sparse_hash_map with a copy of a range.
862
+ </TD>
863
+ </TR>
864
+
865
+ <TR>
866
+ <TD VAlign=top>
867
+ <pre>template &lt;class <A
868
+ href="http://www.sgi.com/tech/stl/InputIterator.html">InputIterator</A>&gt;
869
+ sparse_hash_map(InputIterator f, InputIterator l, size_type n) </pre>
870
+ <A href="#2">[2]</A>
871
+ </TD>
872
+ <TD VAlign=top>
873
+ <A
874
+ href="http://www.sgi.com/tech/stl/UniqueHashedAssociativeContainer.html">Unique
875
+ Hashed Associative Container</A>
876
+ </TD>
877
+ <TD VAlign=top>
878
+ Creates a hash_map with a copy of a range that's optimized to
879
+ hold up to <tt>n</tt> items.
880
+ </TD>
881
+ </TR>
882
+
883
+ <TR>
884
+ <TD VAlign=top>
885
+ <pre>template &lt;class <A
886
+ href="http://www.sgi.com/tech/stl/InputIterator.html">InputIterator</A>&gt;
887
+ sparse_hash_map(InputIterator f, InputIterator l, size_type n, const
888
+ hasher&amp; h) </pre> <A href="#2">[2]</A>
889
+ </TD>
890
+ <TD VAlign=top>
891
+ <A
892
+ href="http://www.sgi.com/tech/stl/UniqueHashedAssociativeContainer.html">Unique
893
+ Hashed Associative Container</A>
894
+ </TD>
895
+ <TD VAlign=top>
896
+ Creates a hash_map with a copy of a range that's optimized to hold
897
+ up to <tt>n</tt> items, using <tt>h</tt> as the hash function.
898
+ </TD>
899
+ </TR>
900
+
901
+ <TR>
902
+ <TD VAlign=top>
903
+ <pre>template &lt;class <A
904
+ href="http://www.sgi.com/tech/stl/InputIterator.html">InputIterator</A>&gt;
905
+ sparse_hash_map(InputIterator f, InputIterator l, size_type n, const
906
+ hasher&amp; h, const key_equal&amp; k) </pre> <A href="#2">[2]</A>
907
+ </TD>
908
+ <TD VAlign=top>
909
+ <A
910
+ href="http://www.sgi.com/tech/stl/UniqueHashedAssociativeContainer.html">Unique
911
+ Hashed Associative Container</A>
912
+ </TD>
913
+ <TD VAlign=top>
914
+ Creates a hash_map with a copy of a range that's optimized for
915
+ holding up to <tt>n</tt> items, using <tt>h</tt> as the hash
916
+ function and <tt>k</tt> as the key equal function.
917
+ </TD>
918
+ </TR>
919
+
920
+ <TR>
921
+ <TD VAlign=top>
922
+ <tt>sparse_hash_map(const hash_map&amp;)</tt>
923
+ </TD>
924
+ <TD VAlign=top>
925
+ <A href="http://www.sgi.com/tech/stl/Container.html">Container</A>
926
+ </TD>
927
+ <TD VAlign=top>
928
+ The copy constructor.
929
+ </TD>
930
+ </TR>
931
+
932
+ <TR>
933
+ <TD VAlign=top>
934
+ <tt>sparse_hash_map&amp; operator=(const hash_map&amp;)</tt>
935
+ </TD>
936
+ <TD VAlign=top>
937
+ <A href="http://www.sgi.com/tech/stl/Container.html">Container</A>
938
+ </TD>
939
+ <TD VAlign=top>
940
+ The assignment operator
941
+ </TD>
942
+ </TR>
943
+
944
+ <TR>
945
+ <TD VAlign=top>
946
+ <tt>void swap(hash_map&amp;)</tt>
947
+ </TD>
948
+ <TD VAlign=top>
949
+ <A href="http://www.sgi.com/tech/stl/Container.html">Container</A>
950
+ </TD>
951
+ <TD VAlign=top>
952
+ Swaps the contents of two hash_maps.
953
+ </TD>
954
+ </TR>
955
+
956
+ <TR>
957
+ <TD VAlign=top>
958
+ <pre>pair&lt;iterator, bool&gt; insert(const value_type&amp; x)
959
+ </pre>
960
+ </TD>
961
+ <TD VAlign=top>
962
+ <A
963
+ href="http://www.sgi.com/tech/stl/UniqueAssociativeContainer.html">Unique
964
+ Associative Container</A>
965
+ </TD>
966
+ <TD VAlign=top>
967
+ Inserts <tt>x</tt> into the <tt>sparse_hash_map</tt>.
968
+ </TD>
969
+ </TR>
970
+
971
+ <TR>
972
+ <TD VAlign=top>
973
+ <pre>template &lt;class <A
974
+ href="http://www.sgi.com/tech/stl/InputIterator.html">InputIterator</A>&gt;
975
+ void insert(InputIterator f, InputIterator l) </pre> <A href="#2">[2]</A>
976
+ </TD>
977
+ <TD VAlign=top>
978
+ <A
979
+ href="http://www.sgi.com/tech/stl/UniqueAssociativeContainer.html">Unique
980
+ Associative Container</A>
981
+ </TD>
982
+ <TD VAlign=top>
983
+ Inserts a range into the <tt>sparse_hash_map</tt>.
984
+ </TD>
985
+ </TR>
986
+
987
+ <TR>
988
+ <TD VAlign=top>
989
+ <tt>void set_deleted_key(const key_type& key)</tt> <A href="#6">[6]</A>
990
+ </TD>
991
+ <TD VAlign=top>
992
+ <tt>sparse_hash_map</tt>
993
+ </TD>
994
+ <TD VAlign=top>
995
+ <A HREF="#new">See below</A>.
996
+ </TD>
997
+ </TR>
998
+
999
+ <TR>
1000
+ <TD VAlign=top>
1001
+ <tt>void clear_deleted_key()</tt> <A href="#6">[6]</A>
1002
+ </TD>
1003
+ <TD VAlign=top>
1004
+ <tt>sparse_hash_map</tt>
1005
+ </TD>
1006
+ <TD VAlign=top>
1007
+ <A HREF="#new">See below</A>.
1008
+ </TD>
1009
+ </TR>
1010
+
1011
+ <TR>
1012
+ <TD VAlign=top>
1013
+ <tt>void erase(iterator pos)</tt>
1014
+ </TD>
1015
+ <TD VAlign=top>
1016
+ <A
1017
+ href="http://www.sgi.com/tech/stl/AssociativeContainer.html">Associative
1018
+ Container</A>
1019
+ </TD>
1020
+ <TD VAlign=top>
1021
+ Erases the element pointed to by <tt>pos</tt>.
1022
+ <A href="#6">[6]</A>
1023
+ </TD>
1024
+ </TR>
1025
+
1026
+ <TR>
1027
+ <TD VAlign=top>
1028
+ <tt>size_type erase(const key_type&amp; k)</tt>
1029
+ </TD>
1030
+ <TD VAlign=top>
1031
+ <A
1032
+ href="http://www.sgi.com/tech/stl/AssociativeContainer.html">Associative
1033
+ Container</A>
1034
+ </TD>
1035
+ <TD VAlign=top>
1036
+ Erases the element whose key is <tt>k</tt>.
1037
+ <A href="#6">[6]</A>
1038
+ </TD>
1039
+ </TR>
1040
+
1041
+ <TR>
1042
+ <TD VAlign=top>
1043
+ <tt>void erase(iterator first, iterator last)</tt>
1044
+ </TD>
1045
+ <TD VAlign=top>
1046
+ <A
1047
+ href="http://www.sgi.com/tech/stl/AssociativeContainer.html">Associative
1048
+ Container</A>
1049
+ </TD>
1050
+ <TD VAlign=top>
1051
+ Erases all elements in a range.
1052
+ <A href="#6">[6]</A>
1053
+ </TD>
1054
+ </TR>
1055
+
1056
+ <TR>
1057
+ <TD VAlign=top>
1058
+ <tt>void clear()</tt>
1059
+ </TD>
1060
+ <TD VAlign=top>
1061
+ <A
1062
+ href="http://www.sgi.com/tech/stl/AssociativeContainer.html">Associative
1063
+ Container</A>
1064
+ </TD>
1065
+ <TD VAlign=top>
1066
+ Erases all of the elements.
1067
+ </TD>
1068
+ </TR>
1069
+
1070
+ <TR>
1071
+ <TD VAlign=top>
1072
+ <tt>const_iterator find(const key_type&amp; k) const</tt>
1073
+ </TD>
1074
+ <TD VAlign=top>
1075
+ <A
1076
+ href="http://www.sgi.com/tech/stl/AssociativeContainer.html">Associative
1077
+ Container</A>
1078
+ </TD>
1079
+ <TD VAlign=top>
1080
+ Finds an element whose key is <tt>k</tt>.
1081
+ </TD>
1082
+ </TR>
1083
+
1084
+ <TR>
1085
+ <TD VAlign=top>
1086
+ <tt>iterator find(const key_type&amp; k)</tt>
1087
+ </TD>
1088
+ <TD VAlign=top>
1089
+ <A
1090
+ href="http://www.sgi.com/tech/stl/AssociativeContainer.html">Associative
1091
+ Container</A>
1092
+ </TD>
1093
+ <TD VAlign=top>
1094
+ Finds an element whose key is <tt>k</tt>.
1095
+ </TD>
1096
+ </TR>
1097
+
1098
+ <TR>
1099
+ <TD VAlign=top>
1100
+ <tt>size_type count(const key_type&amp; k) const</tt>
1101
+ </TD>
1102
+ <TD VAlign=top>
1103
+ <A
1104
+ href="http://www.sgi.com/tech/stl/UniqueAssociativeContainer.html">Unique
1105
+ Associative Container</A>
1106
+ </TD>
1107
+ <TD VAlign=top>
1108
+ Counts the number of elements whose key is <tt>k</tt>.
1109
+ </TD>
1110
+ </TR>
1111
+
1112
+ <TR>
1113
+ <TD VAlign=top>
1114
+ <pre>pair&lt;const_iterator, const_iterator&gt; equal_range(const
1115
+ key_type&amp; k) const </pre>
1116
+ </TD>
1117
+ <TD VAlign=top>
1118
+ <A
1119
+ href="http://www.sgi.com/tech/stl/AssociativeContainer.html">Associative
1120
+ Container</A>
1121
+ </TD>
1122
+ <TD VAlign=top>
1123
+ Finds a range containing all elements whose key is <tt>k</tt>.
1124
+ </TD>
1125
+ </TR>
1126
+
1127
+ <TR>
1128
+ <TD VAlign=top>
1129
+ <pre>pair&lt;iterator, iterator&gt; equal_range(const
1130
+ key_type&amp; k) </pre>
1131
+ </TD>
1132
+ <TD VAlign=top>
1133
+ <A
1134
+ href="http://www.sgi.com/tech/stl/AssociativeContainer.html">Associative
1135
+ Container</A>
1136
+ </TD>
1137
+ <TD VAlign=top>
1138
+ Finds a range containing all elements whose key is <tt>k</tt>.
1139
+ </TD>
1140
+ </TR>
1141
+
1142
+ <TR>
1143
+ <TD VAlign=top>
1144
+ <pre>data_type&amp; operator[](const key_type&amp; k) <A
1145
+ href="http://www.sgi.com/tech/stl/#3">[3]</A> </pre>
1146
+ </TD>
1147
+ <TD VAlign=top>
1148
+ <tt>sparse_hash_map</tt>
1149
+ </TD>
1150
+ <TD VAlign=top>
1151
+ <A HREF="#new">See below</A>.
1152
+ </TD>
1153
+ </TR>
1154
+
1155
+ <TR>
1156
+ <TD VAlign=top>
1157
+ <tt>bool write_metadata(FILE *fp)</tt>
1158
+ </TD>
1159
+ <TD VAlign=top>
1160
+ <tt>sparse_hash_map</tt>
1161
+ </TD>
1162
+ <TD VAlign=top>
1163
+ <A HREF="#new">See below</A>.
1164
+ </TD>
1165
+ </TR>
1166
+
1167
+ <TR>
1168
+ <TD VAlign=top>
1169
+ <tt>bool read_metadata(FILE *fp)</tt>
1170
+ </TD>
1171
+ <TD VAlign=top>
1172
+ <tt>sparse_hash_map</tt>
1173
+ </TD>
1174
+ <TD VAlign=top>
1175
+ <A HREF="#new">See below</A>.
1176
+ </TD>
1177
+ </TR>
1178
+
1179
+ <TR>
1180
+ <TD VAlign=top>
1181
+ <tt>bool write_nopointer_data(FILE *fp)</tt>
1182
+ </TD>
1183
+ <TD VAlign=top>
1184
+ <tt>sparse_hash_map</tt>
1185
+ </TD>
1186
+ <TD VAlign=top>
1187
+ <A HREF="#new">See below</A>.
1188
+ </TD>
1189
+ </TR>
1190
+
1191
+ <TR>
1192
+ <TD VAlign=top>
1193
+ <tt>bool read_nopointer_data(FILE *fp)</tt>
1194
+ </TD>
1195
+ <TD VAlign=top>
1196
+ <tt>sparse_hash_map</tt>
1197
+ </TD>
1198
+ <TD VAlign=top>
1199
+ <A HREF="#new">See below</A>.
1200
+ </TD>
1201
+ </TR>
1202
+
1203
+ <TR>
1204
+ <TD VAlign=top>
1205
+ <pre>bool operator==(const hash_map&amp;, const hash_map&amp;)
1206
+ </pre>
1207
+ </TD>
1208
+ <TD VAlign=top>
1209
+ <A
1210
+ href="http://www.sgi.com/tech/stl/HashedAssociativeContainer.html">Hashed
1211
+ Associative Container</A>
1212
+ </TD>
1213
+ <TD VAlign=top>
1214
+ Tests two hash_maps for equality. This is a global function, not a
1215
+ member function.
1216
+ </TD>
1217
+ </TR>
1218
+
1219
+ </table>
1220
+
1221
+
1222
+ <h3><A NAME="new">New members</A></h3>
1223
+
1224
+ These members are not defined in the <A
1225
+ href="http://www.sgi.com/tech/stl/UniqueHashedAssociativeContainer.html">Unique
1226
+ Hashed Associative Container</A>, <A
1227
+ href="http://www.sgi.com/tech/stl/PairAssociativeContainer.html">Pair
1228
+ Associative Container</A>, or tr1's
1229
+ <tt>Unordered Associative Container</tt> requirements,
1230
+ but are specific to <tt>sparse_hash_map</tt>.
1231
+
1232
+ <table border>
1233
+ <TR><TH>Member</TH><TH>Description</TH></TR>
1234
+
1235
+ <TR>
1236
+ <TR>
1237
+ <TD VAlign=top>
1238
+ <tt>void set_deleted_key(const key_type& key)</tt>
1239
+ </TD>
1240
+ <TD VAlign=top>
1241
+ Sets the distinguished "deleted" key to <tt>key</tt>. This must be
1242
+ called before any calls to <tt>erase()</tt>. <A href="#6">[6]</A>
1243
+ </TD>
1244
+ </TR>
1245
+
1246
+ <TR>
1247
+ <TD VAlign=top>
1248
+ <tt>void clear_deleted_key()</tt>
1249
+ </TD>
1250
+ <TD VAlign=top>
1251
+ Clears the distinguished "deleted" key. After this is called,
1252
+ calls to <tt>erase()</tt> are not valid on this object.
1253
+ <A href="#6">[6]</A>
1254
+ </TD>
1255
+ </TR>
1256
+
1257
+ <TR>
1258
+ <TD VAlign=top>
1259
+ <pre>
1260
+ data_type&amp;
1261
+ operator[](const key_type&amp; k) <A
1262
+ href="http://www.sgi.com/tech/stl/#3">[3]</A>
1263
+ </pre>
1264
+ </TD>
1265
+ <TD VAlign=top>
1266
+ Returns a reference to the object that is associated with
1267
+ a particular key. If the <tt>sparse_hash_map</tt> does not already
1268
+ contain such an object, <tt>operator[]</tt> inserts the default
1269
+ object <tt>data_type()</tt>. <A
1270
+ href="http://www.sgi.com/tech/stl/#3">[3]</A>
1271
+ </TD>
1272
+ </TR>
1273
+
1274
+ <TD VAlign=top>
1275
+ <tt>void set_resizing_parameters(float shrink, float grow)</tt>
1276
+ </TD>
1277
+ <TD VAlign=top>
1278
+ This function is DEPRECATED. It is equivalent to calling
1279
+ <tt>min_load_factor(shrink); max_load_factor(grow)</tt>.
1280
+ </TD>
1281
+ </TR>
1282
+
1283
+ <TR>
1284
+ <TD VAlign=top>
1285
+ <tt>bool write_metadata(FILE *fp)</tt>
1286
+ </TD>
1287
+ <TD VAlign=top>
1288
+ Write hashtable metadata to <tt>fp</tt>. See <A HREF="#io">below</A>.
1289
+ </TD>
1290
+ </TR>
1291
+
1292
+ <TR>
1293
+ <TD VAlign=top>
1294
+ <tt>bool read_metadata(FILE *fp)</tt>
1295
+ </TD>
1296
+ <TD VAlign=top>
1297
+ Read hashtable metadata from <tt>fp</tt>. See <A HREF="#io">below</A>.
1298
+ </TD>
1299
+ </TR>
1300
+
1301
+ <TR>
1302
+ <TD VAlign=top>
1303
+ <tt>bool write_nopointer_data(FILE *fp)</tt>
1304
+ </TD>
1305
+ <TD VAlign=top>
1306
+ Write hashtable contents to <tt>fp</tt>. This is valid only if the
1307
+ hashtable key and value are "plain" data. See <A HREF="#io">below</A>.
1308
+ </TD>
1309
+ </TR>
1310
+
1311
+ <TR>
1312
+ <TD VAlign=top>
1313
+ <tt>bool read_nopointer_data(FILE *fp)</tt>
1314
+ </TD>
1315
+ <TD VAlign=top>
1316
+ Read hashtable contents to <tt>fp</tt>. This is valid only if the
1317
+ hashtable key and value are "plain" data. See <A HREF="#io">below</A>.
1318
+ </TD>
1319
+ </TR>
1320
+
1321
+ </table>
1322
+
1323
+
1324
+ <h3>Notes</h3>
1325
+
1326
+ <P><A name="1">[1]</A>
1327
+
1328
+ <tt>sparse_hash_map::iterator</tt> is not a mutable iterator, because
1329
+ <tt>sparse_hash_map::value_type</tt> is not <A
1330
+ href="http://www.sgi.com/tech/stl/Assignable.html">Assignable</A>.
1331
+ That is, if <tt>i</tt> is of type <tt>sparse_hash_map::iterator</tt>
1332
+ and <tt>p</tt> is of type <tt>sparse_hash_map::value_type</tt>, then
1333
+ <tt>*i = p</tt> is not a valid expression. However,
1334
+ <tt>sparse_hash_map::iterator</tt> isn't a constant iterator either,
1335
+ because it can be used to modify the object that it points to. Using
1336
+ the same notation as above, <tt>(*i).second = p</tt> is a valid
1337
+ expression.</p>
1338
+
1339
+ <P><A name="2">[2]</A>
1340
+
1341
+ This member function relies on <i>member template</i> functions, which
1342
+ may not be supported by all compilers. If your compiler supports
1343
+ member templates, you can call this function with any type of <A
1344
+ href="http://www.sgi.com/tech/stl/InputIterator.html">input
1345
+ iterator</A>. If your compiler does not yet support member templates,
1346
+ though, then the arguments must either be of type <tt>const
1347
+ value_type*</tt> or of type <tt>sparse_hash_map::const_iterator</tt>.</p>
1348
+
1349
+ <P><A name="3">[3]</A>
1350
+
1351
+ Since <tt>operator[]</tt> might insert a new element into the
1352
+ <tt>sparse_hash_map</tt>, it can't possibly be a <tt>const</tt> member
1353
+ function. Note that the definition of <tt>operator[]</tt> is
1354
+ extremely simple: <tt>m[k]</tt> is equivalent to
1355
+ <tt>(*((m.insert(value_type(k, data_type()))).first)).second</tt>.
1356
+ Strictly speaking, this member function is unnecessary: it exists only
1357
+ for convenience.</p>
1358
+
1359
+ <P><A name="4">[4]</A>
1360
+
1361
+ In order to preserve iterators, erasing hashtable elements does not
1362
+ cause a hashtable to resize. This means that after a string of
1363
+ <tt>erase()</tt> calls, the hashtable will use more space than is
1364
+ required. At a cost of invalidating all current iterators, you can
1365
+ call <tt>resize()</tt> to manually compact the hashtable. The
1366
+ hashtable promotes too-small <tt>resize()</tt> arguments to the
1367
+ smallest legal value, so to compact a hashtable, it's sufficient to
1368
+ call <tt>resize(0)</tt>.
1369
+
1370
+ <P><A name="5">[5]</A>
1371
+
1372
+ Unlike some other hashtable implementations, the optional <i>n</i> in
1373
+ the calls to the constructor, <tt>resize</tt>, and <tt>rehash</tt>
1374
+ indicates not the desired number of buckets that
1375
+ should be allocated, but instead the expected number of items to be
1376
+ inserted. The class then sizes the hash-map appropriately for the
1377
+ number of items specified. It's not an error to actually insert more
1378
+ or fewer items into the hashtable, but the implementation is most
1379
+ efficient -- does the fewest hashtable resizes -- if the number of
1380
+ inserted items is <i>n</i> or slightly less.</p>
1381
+
1382
+ <P><A name="6">[6]</A>
1383
+
1384
+ <tt>sparse_hash_map</tt> <b>requires</b> you call
1385
+ <tt>set_deleted_key()</tt> before calling <tt>erase()</tt>. (This is
1386
+ the largest difference between the <tt>sparse_hash_map</tt> API and
1387
+ other hash-map APIs. See <A HREF="implementation.html">implementation.html</A>
1388
+ for why this is necessary.)
1389
+ The argument to <tt>set_deleted_key()</tt> should be a key-value that
1390
+ is never used for legitimate hash-map entries. It is an error to call
1391
+ <tt>erase()</tt> without first calling <tt>set_deleted_key()</tt>, and
1392
+ it is also an error to call <tt>insert()</tt> with an item whose key
1393
+ is the "deleted key."</p>
1394
+
1395
+ <p>There is no need to call <tt>set_deleted_key</tt> if you do not
1396
+ wish to call <tt>erase()</tt> on the hash-map.</p>
1397
+
1398
+ <p>It is acceptable to change the deleted-key at any time by calling
1399
+ <tt>set_deleted_key()</tt> with a new argument. You can also call
1400
+ <tt>clear_deleted_key()</tt>, at which point all keys become valid for
1401
+ insertion but no hashtable entries can be deleted until
1402
+ <tt>set_deleted_key()</tt> is called again.</p>
1403
+
1404
+ <p><b>Note:</b> If you use <tt>set_deleted_key</tt>, it is also
1405
+ necessary that <tt>data_type</tt> has a zero-argument default
1406
+ constructor. This is because <tt>sparse_hash_map</tt> uses the
1407
+ special value <tt>pair(deleted_key, data_type())</tt> to denote
1408
+ deleted buckets, and thus needs to be able to create
1409
+ <tt>data_type</tt> using a zero-argument constructor.</p>
1410
+
1411
+ <p>If your <tt>data_type</tt> does not have a zero-argument default
1412
+ constructor, there are several workarounds:</p>
1413
+ <ul>
1414
+ <li> Store a pointer to <tt>data_type</tt> in the map, instead of
1415
+ <tt>data_type</tt> directly. This may yield faster code as
1416
+ well, since hashtable-resizes will just have to move pointers
1417
+ around, rather than copying the entire <tt>data_type</tt>.
1418
+ <li> Add a zero-argument default constructor to <tt>data_type</tt>.
1419
+ <li> Subclass <tt>data_type</tt> and add a zero-argument default
1420
+ constructor to the subclass.
1421
+ </ul>
1422
+
1423
+ <p>If you do not use <tt>set_deleted_key</tt>, then there is no
1424
+ requirement that <tt>data_type</tt> havea zero-argument default
1425
+ constructor.
1426
+
1427
+
1428
+ <h3><A NAME=io>Input/Output</A></h3>
1429
+
1430
+ <p>It is possible to save and restore <tt>sparse_hash_map</tt> objects
1431
+ to disk. Storage takes place in two steps. The first writes the
1432
+ hashtable metadata. The second writes the actual data.</p>
1433
+
1434
+ <p>To write a hashtable to disk, first call <tt>write_metadata()</tt>
1435
+ on an open file pointer. This saves the hashtable information in a
1436
+ byte-order-independent format.</p>
1437
+
1438
+ <p>After the metadata has been written to disk, you must write the
1439
+ actual data stored in the hash-map to disk. If both the key and data
1440
+ are "simple" enough, you can do this by calling
1441
+ <tt>write_nopointer_data()</tt>. "Simple" data is data that can be
1442
+ safely copied to disk via <tt>fwrite()</tt>. Native C data types fall
1443
+ into this category, as do structs of native C data types. Pointers
1444
+ and STL objects do not.</p>
1445
+
1446
+ <p>Note that <tt>write_nopointer_data()</tt> does not do any endian
1447
+ conversion. Thus, it is only appropriate when you intend to read the
1448
+ data on the same endian architecture as you write the data.</p>
1449
+
1450
+ <p>If you cannot use <tt>write_nopointer_data()</tt> for any reason,
1451
+ you can write the data yourself by iterating over the
1452
+ <tt>sparse_hash_map</tt> with a <tt>const_iterator</tt> and writing
1453
+ the key and data in any manner you wish.</p>
1454
+
1455
+ <p>To read the hashtable information from disk, first you must create
1456
+ a <tt>sparse_hash_map</tt> object. Then open a file pointer to point
1457
+ to the saved hashtable, and call <tt>read_metadata()</tt>. If you
1458
+ saved the data via <tt>write_nopointer_data()</tt>, you can follow the
1459
+ <tt>read_metadata()</tt> call with a call to
1460
+ <tt>read_nopointer_data()</tt>. This is all that is needed.</p>
1461
+
1462
+ <p>If you saved the data through a custom write routine, you must call
1463
+ a custom read routine to read in the data. To do this, iterate over
1464
+ the <tt>sparse_hash_map</tt> with an <tt>iterator</tt>; this operation
1465
+ is sensical because the metadata has already been set up. For each
1466
+ iterator item, you can read the key and value from disk, and set it
1467
+ appropriately. You will need to do a <tt>const_cast</tt> on the
1468
+ iterator, since <tt>it-&gt;first</tt> is always <tt>const</tt>. You
1469
+ will also need to use placement-new if the key or value is a C++
1470
+ object. The code might look like this:</p>
1471
+ <pre>
1472
+ for (sparse_hash_map&lt;int*, ComplicatedClass&gt;::iterator it = ht.begin();
1473
+ it != ht.end(); ++it) {
1474
+ // The key is stored in the sparse_hash_map as a pointer
1475
+ const_cast&lt;int*&gt;(it-&gt;first) = new int;
1476
+ fread(const_cast&lt;int*&gt;(it-&gt;first), sizeof(int), 1, fp);
1477
+ // The value is a complicated C++ class that takes an int to construct
1478
+ int ctor_arg;
1479
+ fread(&ctor_arg, sizeof(int), 1, fp);
1480
+ new (&it-&gt;second) ComplicatedClass(ctor_arg); // "placement new"
1481
+ }
1482
+ </pre>
1483
+
1484
+
1485
+ <h3><A NAME=iter>Validity of Iterators</A></h3>
1486
+
1487
+ <p><tt>erase()</tt> is guaranteed not to invalidate any iterators --
1488
+ except for any iterators pointing to the item being erased, of course.
1489
+ <tt>insert()</tt> invalidates all iterators, as does
1490
+ <tt>resize()</tt>. </p>
1491
+
1492
+ <p>This is implemented by making <tt>erase()</tt> not resize the
1493
+ hashtable. If you desire maximum space efficiency, you can call
1494
+ <tt>resize(0)</tt> after a string of <tt>erase()</tt> calls, to force
1495
+ the hashtable to resize to the smallest possible size.</p>
1496
+
1497
+ <p>In addition to invalidating iterators, <tt>insert()</tt>
1498
+ and <tt>resize()</tt> invalidate all pointers into the hashtable. If
1499
+ you want to store a pointer to an object held in a sparse_hash_map,
1500
+ either do so after finishing hashtable inserts, or store the object on
1501
+ the heap and a pointer to it in the sparse_hash_map.</p>
1502
+
1503
+
1504
+ <h3>See also</h3>
1505
+
1506
+ <p>The following are SGI STL, and some Google STL, concepts and
1507
+ classes related to <tt>sparse_hash_map</tt>.</p>
1508
+
1509
+ <tt><A href="http://www.sgi.com/tech/stl/hash_map.html">hash_map</A></tt>,
1510
+ <A href="http://www.sgi.com/tech/stl/AssociativeContainer.html">Associative Container</A>,
1511
+ <A href="http://www.sgi.com/tech/stl/HashedAssociativeContainer.html">Hashed Associative Container</A>,
1512
+ <A href="http://www.sgi.com/tech/stl/PairAssociativeContainer.html">Pair Associative Container</A>,
1513
+ <A href="http://www.sgi.com/tech/stl/UniqueHashedAssociativeContainer.html">Unique Hashed Associative Container</A>,
1514
+ <tt><A href="http://www.sgi.com/tech/stl/set.html">set</A></tt>,
1515
+ <tt><A href="http://www.sgi.com/tech/stl/Map.html">map</A></tt>
1516
+ <tt><A href="http://www.sgi.com/tech/stl/multiset.html">multiset</A></tt>,
1517
+ <tt><A href="http://www.sgi.com/tech/stl/Multimap.html">multimap</A></tt>,
1518
+ <tt><A href="http://www.sgi.com/tech/stl/hash_set.html">hash_set</A></tt>,
1519
+ <tt><A href="http://www.sgi.com/tech/stl/hash_multiset.html">hash_multiset</A></tt>,
1520
+ <tt><A href="http://www.sgi.com/tech/stl/hash_multimap.html">hash_multimap</A></tt>,
1521
+ <tt><A href="sparsetable.html">sparsetable</A></tt>,
1522
+ <tt><A href="sparse_hash_set.html">sparse_hash_set</A></tt>,
1523
+ <tt><A href="dense_hash_set.html">dense_hash_set</A></tt>,
1524
+ <tt><A href="dense_hash_map.html">dense_hash_map</A></tt>
1525
+
1526
+ </BODY>
1527
+ </HTML>