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