]> git.ipfire.org Git - thirdparty/gcc.git/blame - libstdc++-v3/include/ext/pb_assoc/detail/hash_fn/ranged_probe_fn.hpp
projects / thirdparty / gcc.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
* typeck.c (build_modify_expr): Tidy diagnostic message.
[thirdparty/gcc.git] / libstdc++-v3 / include / ext / pb_assoc / detail / hash_fn / ranged_probe_fn.hpp
CommitLineData
fd1e1726
BK		 1// -*- C++ -*-
2
3// Copyright (C) 2005 Free Software Foundation, Inc.
4//
5// This file is part of the GNU ISO C++ Library. This library is free
6// software; you can redistribute it and/or modify it under the
7// terms of the GNU General Public License as published by the
8// Free Software Foundation; either version 2, or (at your option)
9// any later version.
10
11// This library is distributed in the hope that it will be useful,
12// but WITHOUT ANY WARRANTY; without even the implied warranty of
13// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14// GNU General Public License for more details.
15
16// You should have received a copy of the GNU General Public License along
17// with this library; see the file COPYING. If not, write to the Free
83f51799 18// Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
fd1e1726
BK		 19// USA.
20
21// As a special exception, you may use this file as part of a free software
22// library without restriction. Specifically, if other files instantiate
23// templates or use macros or inline functions from this file, or you compile
24// this file and link it with other files to produce an executable, this
25// file does not by itself cause the resulting executable to be covered by
26// the GNU General Public License. This exception does not however
27// invalidate any other reasons why the executable file might be covered by
28// the GNU General Public License.
29
30// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
31
32// Permission to use, copy, modify, sell, and distribute this software
33// is hereby granted without fee, provided that the above copyright
34// notice appears in all copies, and that both that copyright notice and
35// this permission notice appear in supporting documentation. None of
36// the above authors, nor IBM Haifa Research Laboratories, make any
37// representation about the suitability of this software for any
38// purpose. It is provided "as is" without express or implied warranty.
39
40/**
41 * @file ranged_probe_fn.hpp
42 * Contains a unified ranged probe functor, allowing the probe tables to deal with
43 * a single class for ranged probeing.
44 */
45
46#ifndef RANGED_PROBE_FN_HPP
47#define RANGED_PROBE_FN_HPP
48
49#include <ext/pb_assoc/hash_policy.hpp>
50#include <utility>
51
52namespace pb_assoc
53{
54
55 namespace detail
56 {
57
58#ifdef PB_ASSOC_RANGED_PROBE_FN_DEBUG
59#define PB_ASSOC_DBG_ASSERT(X) assert(X)
60#define PB_ASSOC_DBG_VERIFY(X) assert(X)
61#define PB_ASSOC_DBG_ONLY(X) X
62#else // #ifdef PB_ASSOC_RANGED_PROBE_FN_DEBUG
63#define PB_ASSOC_DBG_ASSERT(X)
64#define PB_ASSOC_DBG_VERIFY(X) {if((X)==0);}
65#define PB_ASSOC_DBG_ONLY(X) ;
66#endif // #ifdef PB_ASSOC_RANGED_PROBE_FN_DEBUG
67
68 template<typename Key,
69 class Hash_Fn,
70 class Allocator,
71 class Comb_Probe_Fn,
72 class Probe_Fn,
73 bool Store_Hash>
74 class ranged_probe_fn;
75
76#define PB_ASSOC_CLASS_T_DEC \
77 template< \
78 typename Key, \
79 class Hash_Fn, \
80 class Allocator, \
81 class Comb_Probe_Fn, \
82 class Probe_Fn>
83
84#define PB_ASSOC_CLASS_C_DEC \
85 ranged_probe_fn< \
86 Key, \
87 Hash_Fn, \
88 Allocator, \
89 Comb_Probe_Fn, \
90 Probe_Fn, \
91 false>
92
93 /**
94 * Specialization 1- The client supplies a probe function and a ranged
95 * probe function, and requests that hash values not be stored.
96 **/
97 template<typename Key,
98 class Hash_Fn,
99 class Allocator,
100 class Comb_Probe_Fn,
101 class Probe_Fn>
102 class ranged_probe_fn<
103 Key,
104 Hash_Fn,
105 Allocator,
106 Comb_Probe_Fn,
107 Probe_Fn,
108 false> : public Hash_Fn,
109 public Comb_Probe_Fn,
110 public Probe_Fn
111 {
112 protected:
113 typedef typename Allocator::size_type size_type;
114
115 typedef Comb_Probe_Fn my_comb_probe_fn_base;
116
117 typedef Hash_Fn my_hash_fn_base;
118
119 typedef Probe_Fn my_probe_fn_base;
120
121 typedef typename Allocator::template rebind< Key>::other key_allocator;
122
123 typedef typename key_allocator::const_reference const_key_reference;
124
125 protected:
126 ranged_probe_fn(size_type size);
127
128 ranged_probe_fn(size_type size, const Hash_Fn& r_hash_fn);
129
130 ranged_probe_fn(size_type size, const Hash_Fn& r_hash_fn, const Comb_Probe_Fn& r_comb_probe_fn);
131
132 ranged_probe_fn(size_type size, const Hash_Fn& r_hash_fn, const Comb_Probe_Fn& r_comb_probe_fn, const Probe_Fn& r_probe_fn);
133
134 void
135 swap(PB_ASSOC_CLASS_C_DEC& r_other);
136
137 void
138 notify_resized(size_type size);
139
140 inline size_type
141 operator()(const_key_reference r_key) const;
142
143 inline size_type
144 operator()(const_key_reference r_key, size_type hash, size_type i) const;
145 };
146
147 PB_ASSOC_CLASS_T_DEC
148 PB_ASSOC_CLASS_C_DEC::
149 ranged_probe_fn(size_type size)
150 {
151 Comb_Probe_Fn::notify_resized(size);
152 }
153
154 PB_ASSOC_CLASS_T_DEC
155 PB_ASSOC_CLASS_C_DEC::
156 ranged_probe_fn(size_type size, const Hash_Fn& r_hash_fn) :
157 Hash_Fn(r_hash_fn)
158 {
159 Comb_Probe_Fn::notify_resized(size);
160 }
161
162 PB_ASSOC_CLASS_T_DEC
163 PB_ASSOC_CLASS_C_DEC::
164 ranged_probe_fn(size_type size, const Hash_Fn& r_hash_fn, const Comb_Probe_Fn& r_comb_probe_fn) :
165 Hash_Fn(r_hash_fn),
166 Comb_Probe_Fn(r_comb_probe_fn)
167 {
168 my_comb_probe_fn_base::notify_resized(size);
169 }
170
171 PB_ASSOC_CLASS_T_DEC
172 PB_ASSOC_CLASS_C_DEC::
173 ranged_probe_fn(size_type size, const Hash_Fn& r_hash_fn, const Comb_Probe_Fn& r_comb_probe_fn, const Probe_Fn& r_probe_fn) :
174 Hash_Fn(r_hash_fn),
175 Comb_Probe_Fn(r_comb_probe_fn),
176 Probe_Fn(r_probe_fn)
177 {
178 my_comb_probe_fn_base::notify_resized(size);
179 }
180
181 PB_ASSOC_CLASS_T_DEC
182 void
183 PB_ASSOC_CLASS_C_DEC::
184 swap(PB_ASSOC_CLASS_C_DEC& r_other)
185 {
186 my_comb_probe_fn_base::swap(r_other);
187
188 std::swap((Hash_Fn& )(*this), (Hash_Fn& )r_other);
189 }
190
191 PB_ASSOC_CLASS_T_DEC
192 void
193 PB_ASSOC_CLASS_C_DEC::
194 notify_resized(size_type size)
195 {
196 my_comb_probe_fn_base::notify_resized(size);
197 }
198
199 PB_ASSOC_CLASS_T_DEC
200 inline typename PB_ASSOC_CLASS_C_DEC::size_type
201 PB_ASSOC_CLASS_C_DEC::
202 operator()(const_key_reference r_key) const
203 {
204 return (my_comb_probe_fn_base::operator()(
205 my_hash_fn_base::operator()(r_key)));
206 }
207
208 PB_ASSOC_CLASS_T_DEC
209 inline typename PB_ASSOC_CLASS_C_DEC::size_type
210 PB_ASSOC_CLASS_C_DEC::
211 operator()(const_key_reference r_key, size_type hash, size_type i) const
212 {
213 return (my_comb_probe_fn_base::operator()(
214 hash + my_probe_fn_base::operator()(r_key, i)));
215 }
216
217#undef PB_ASSOC_CLASS_T_DEC
218#undef PB_ASSOC_CLASS_C_DEC
219
220#define PB_ASSOC_CLASS_T_DEC \
221 template< \
222 typename Key, \
223 class Hash_Fn, \
224 class Allocator, \
225 class Comb_Probe_Fn, \
226 class Probe_Fn>
227
228#define PB_ASSOC_CLASS_C_DEC \
229 ranged_probe_fn< \
230 Key, \
231 Hash_Fn, \
232 Allocator, \
233 Comb_Probe_Fn, \
234 Probe_Fn, \
235 true>
236
237 /**
238 * Specialization 2- The client supplies a probe function and a ranged
239 * probe function, and requests that hash values be stored.
240 **/
241 template<typename Key,
242 class Hash_Fn,
243 class Allocator,
244 class Comb_Probe_Fn,
245 class Probe_Fn>
246 class ranged_probe_fn<
247 Key,
248 Hash_Fn,
249 Allocator,
250 Comb_Probe_Fn,
251 Probe_Fn,
252 true> :
253 public Hash_Fn,
254 public Comb_Probe_Fn,
255 public Probe_Fn
256 {
257 protected:
258 typedef typename Allocator::size_type size_type;
259
260 typedef std::pair<size_type, size_type> comp_hash;
261
262 typedef Comb_Probe_Fn my_comb_probe_fn_base;
263
264 typedef Hash_Fn my_hash_fn_base;
265
266 typedef Probe_Fn my_probe_fn_base;
267
268 typedef typename Allocator::template rebind<Key>::other key_allocator;
269
270 typedef typename key_allocator::const_reference const_key_reference;
271
272 protected:
273 ranged_probe_fn(size_type size);
274
275 ranged_probe_fn(size_type size, const Hash_Fn& r_hash_fn);
276
277 ranged_probe_fn(size_type size, const Hash_Fn& r_hash_fn, const Comb_Probe_Fn& r_comb_probe_fn);
278
279 ranged_probe_fn(size_type size, const Hash_Fn& r_hash_fn, const Comb_Probe_Fn& r_comb_probe_fn, const Probe_Fn& r_probe_fn);
280
281 void
282 swap(PB_ASSOC_CLASS_C_DEC& r_other);
283
284 void
285 notify_resized(size_type size);
286
287 inline comp_hash
288 operator()(const_key_reference r_key) const;
289
290 inline size_type
291 operator()(const_key_reference r_key, size_type hash, size_type i) const;
292
293 inline size_type
294 operator()(const_key_reference r_key, size_type hash) const;
295 };
296
297 PB_ASSOC_CLASS_T_DEC
298 PB_ASSOC_CLASS_C_DEC::
299 ranged_probe_fn(size_type size)
300 {
301 Comb_Probe_Fn::notify_resized(size);
302 }
303
304 PB_ASSOC_CLASS_T_DEC
305 PB_ASSOC_CLASS_C_DEC::
306 ranged_probe_fn(size_type size, const Hash_Fn& r_hash_fn) :
307 Hash_Fn(r_hash_fn)
308 {
309 Comb_Probe_Fn::notify_resized(size);
310 }
311
312 PB_ASSOC_CLASS_T_DEC
313 PB_ASSOC_CLASS_C_DEC::
314 ranged_probe_fn(size_type size, const Hash_Fn& r_hash_fn, const Comb_Probe_Fn& r_comb_probe_fn) :
315 Hash_Fn(r_hash_fn),
316 Comb_Probe_Fn(r_comb_probe_fn)
317 {
318 my_comb_probe_fn_base::notify_resized(size);
319 }
320
321 PB_ASSOC_CLASS_T_DEC
322 PB_ASSOC_CLASS_C_DEC::
323 ranged_probe_fn(size_type size, const Hash_Fn& r_hash_fn, const Comb_Probe_Fn& r_comb_probe_fn, const Probe_Fn& r_probe_fn) :
324 Hash_Fn(r_hash_fn),
325 Comb_Probe_Fn(r_comb_probe_fn),
326 Probe_Fn(r_probe_fn)
327 {
328 my_comb_probe_fn_base::notify_resized(size);
329 }
330
331 PB_ASSOC_CLASS_T_DEC
332 void
333 PB_ASSOC_CLASS_C_DEC::
334 swap(PB_ASSOC_CLASS_C_DEC& r_other)
335 {
336 my_comb_probe_fn_base::swap(r_other);
337
338 std::swap((Hash_Fn& )(*this), (Hash_Fn& )r_other);
339 }
340
341 PB_ASSOC_CLASS_T_DEC
342 void
343 PB_ASSOC_CLASS_C_DEC::
344 notify_resized(size_type size)
345 {
346 my_comb_probe_fn_base::notify_resized(size);
347 }
348
349 PB_ASSOC_CLASS_T_DEC
350 inline typename PB_ASSOC_CLASS_C_DEC::comp_hash
351 PB_ASSOC_CLASS_C_DEC::
352 operator()(const_key_reference r_key) const
353 {
354 const size_type hash = my_hash_fn_base::operator()(r_key);
355
356 return (std::make_pair(my_comb_probe_fn_base::operator()(hash), hash));
357 }
358
359 PB_ASSOC_CLASS_T_DEC
360 inline typename PB_ASSOC_CLASS_C_DEC::size_type
361 PB_ASSOC_CLASS_C_DEC::
362 operator()(const_key_reference r_key, size_type hash, size_type i) const
363 {
364 return (my_comb_probe_fn_base::operator()(
365 hash + my_probe_fn_base::operator()(r_key, i)));
366 }
367
368 PB_ASSOC_CLASS_T_DEC
369 inline typename PB_ASSOC_CLASS_C_DEC::size_type
370 PB_ASSOC_CLASS_C_DEC::
371 operator()
372#ifdef PB_ASSOC_RANGED_PROBE_FN_DEBUG
373 (const_key_reference r_key, size_type hash) const
374#else // #ifdef PB_ASSOC_RANGED_PROBE_FN_DEBUG
375 (const_key_reference /*r_key*/, size_type hash) const
376#endif // #ifdef PB_ASSOC_RANGED_PROBE_FN_DEBUG
377 {
378 PB_ASSOC_DBG_ASSERT(hash == my_hash_fn_base::operator()(r_key));
379
380 return (hash);
381 }
382
383#undef PB_ASSOC_CLASS_T_DEC
384#undef PB_ASSOC_CLASS_C_DEC
385
386#define PB_ASSOC_CLASS_T_DEC \
387 template<typename Key, class Allocator, class Comb_Probe_Fn>
388
389#define PB_ASSOC_CLASS_C_DEC \
390 ranged_probe_fn< \
391 Key, \
392 null_hash_fn, \
393 Allocator, \
394 Comb_Probe_Fn, \
395 null_probe_fn, \
396 false>
397
398 /**
399 * Specialization 3 and 4- The client does not supply a hash function or
400 * probe function, and requests that hash values not be stored.
401 **/
402 template<typename Key, class Allocator, class Comb_Probe_Fn>
403 class ranged_probe_fn<
404 Key,
405 null_hash_fn,
406 Allocator,
407 Comb_Probe_Fn,
408 null_probe_fn,
409 false> :
410 public Comb_Probe_Fn,
411 public null_hash_fn,
412 public null_probe_fn
413 {
414 protected:
415 typedef typename Allocator::size_type size_type;
416
417 typedef Comb_Probe_Fn my_comb_probe_fn_base;
418
419 typedef typename Allocator::template rebind<Key>::other key_allocator;
420
421 typedef typename key_allocator::const_reference const_key_reference;
422
423 protected:
424 ranged_probe_fn(size_type size);
425
426 ranged_probe_fn(size_type size, const Comb_Probe_Fn& r_comb_probe_fn);
427
428 ranged_probe_fn(size_type size, const null_hash_fn& r_null_hash_fn, const Comb_Probe_Fn& r_comb_probe_fn, const null_probe_fn& r_null_probe_fn);
429
430 void
431 swap(PB_ASSOC_CLASS_C_DEC& r_other);
432 };
433
434 PB_ASSOC_CLASS_T_DEC
435 PB_ASSOC_CLASS_C_DEC::
436 ranged_probe_fn(size_type size)
437 {
438 Comb_Probe_Fn::notify_resized(size);
439 }
440
441 PB_ASSOC_CLASS_T_DEC
442 PB_ASSOC_CLASS_C_DEC::
443 ranged_probe_fn(size_type size, const Comb_Probe_Fn& r_comb_probe_fn) :
444 Comb_Probe_Fn(r_comb_probe_fn)
445 { }
446
447 PB_ASSOC_CLASS_T_DEC
448 PB_ASSOC_CLASS_C_DEC::
449 ranged_probe_fn(size_type size, const null_hash_fn& r_null_hash_fn, const Comb_Probe_Fn& r_comb_probe_fn, const null_probe_fn& r_null_probe_fn) :
450 Comb_Probe_Fn(r_comb_probe_fn)
451 { }
452
453 PB_ASSOC_CLASS_T_DEC
454 void
455 PB_ASSOC_CLASS_C_DEC::
456 swap(PB_ASSOC_CLASS_C_DEC& r_other)
457 {
458 my_comb_probe_fn_base::swap(r_other);
459 }
460
461#undef PB_ASSOC_CLASS_T_DEC
462#undef PB_ASSOC_CLASS_C_DEC
463
464#undef PB_ASSOC_DBG_ASSERT
465#undef PB_ASSOC_DBG_VERIFY
466#undef PB_ASSOC_DBG_ONLY
467
468 } // namespace detail
469
470} // namespace pb_assoc
471
472#endif // #ifndef RANGED_PROBE_FN_HPP
473
Mirror of https://gcc.gnu.org/git/gcc.git