google_hash 0.0.0

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