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