libstdc++
profile/unordered_set
1 // Profiling unordered_set/unordered_multiset implementation -*- C++ -*-
2 
3 // Copyright (C) 2009-2015 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 3, 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 // Under Section 7 of GPL version 3, you are granted additional
17 // permissions described in the GCC Runtime Library Exception, version
18 // 3.1, as published by the Free Software Foundation.
19 
20 // You should have received a copy of the GNU General Public License along
21 // with this library; see the file COPYING3. If not see
22 // <http://www.gnu.org/licenses/>.
23 
24 /** @file profile/unordered_set
25  * This file is a GNU profile extension to the Standard C++ Library.
26  */
27 
28 #ifndef _GLIBCXX_PROFILE_UNORDERED_SET
29 #define _GLIBCXX_PROFILE_UNORDERED_SET 1
30 
31 #if __cplusplus < 201103L
32 # include <bits/c++0x_warning.h>
33 #else
34 # include <unordered_set>
35 
36 #include <profile/base.h>
37 #include <profile/unordered_base.h>
38 
39 #define _GLIBCXX_BASE unordered_set<_Key, _Hash, _Pred, _Alloc>
40 #define _GLIBCXX_STD_BASE _GLIBCXX_STD_C::_GLIBCXX_BASE
41 
42 namespace std _GLIBCXX_VISIBILITY(default)
43 {
44 namespace __profile
45 {
46  /** @brief Unordered_set wrapper with performance instrumentation. */
47  template<typename _Key,
48  typename _Hash = std::hash<_Key>,
49  typename _Pred = std::equal_to<_Key>,
50  typename _Alloc = std::allocator<_Key> >
51  class unordered_set
52  : public _GLIBCXX_STD_BASE,
53  public _Unordered_profile<unordered_set<_Key, _Hash, _Pred, _Alloc>,
54  true>
55  {
56  typedef _GLIBCXX_STD_BASE _Base;
57 
58  _Base&
59  _M_base() noexcept { return *this; }
60 
61  const _Base&
62  _M_base() const noexcept { return *this; }
63 
64  public:
65  typedef typename _Base::size_type size_type;
66  typedef typename _Base::hasher hasher;
67  typedef typename _Base::key_equal key_equal;
68  typedef typename _Base::allocator_type allocator_type;
69  typedef typename _Base::key_type key_type;
70  typedef typename _Base::value_type value_type;
71  typedef typename _Base::difference_type difference_type;
72  typedef typename _Base::reference reference;
73  typedef typename _Base::const_reference const_reference;
74 
75  typedef typename _Base::iterator iterator;
76  typedef typename _Base::const_iterator const_iterator;
77 
78  unordered_set() = default;
79 
80  explicit
81  unordered_set(size_type __n,
82  const hasher& __hf = hasher(),
83  const key_equal& __eql = key_equal(),
84  const allocator_type& __a = allocator_type())
85  : _Base(__n, __hf, __eql, __a)
86  { }
87 
88  template<typename _InputIterator>
89  unordered_set(_InputIterator __f, _InputIterator __l,
90  size_type __n = 0,
91  const hasher& __hf = hasher(),
92  const key_equal& __eql = key_equal(),
93  const allocator_type& __a = allocator_type())
94  : _Base(__f, __l, __n, __hf, __eql, __a)
95  { }
96 
97  unordered_set(const unordered_set&) = default;
98 
99  unordered_set(const _Base& __x)
100  : _Base(__x)
101  { }
102 
103  unordered_set(unordered_set&&) = default;
104 
105  explicit
106  unordered_set(const allocator_type& __a)
107  : _Base(__a)
108  { }
109 
110  unordered_set(const unordered_set& __uset,
111  const allocator_type& __a)
112  : _Base(__uset._M_base(), __a)
113  { }
114 
115  unordered_set(unordered_set&& __uset,
116  const allocator_type& __a)
117  : _Base(std::move(__uset._M_base()), __a)
118  { }
119 
120  unordered_set(initializer_list<value_type> __l,
121  size_type __n = 0,
122  const hasher& __hf = hasher(),
123  const key_equal& __eql = key_equal(),
124  const allocator_type& __a = allocator_type())
125  : _Base(__l, __n, __hf, __eql, __a)
126  { }
127 
128  unordered_set&
129  operator=(const unordered_set&) = default;
130 
131  unordered_set&
132  operator=(unordered_set&&) = default;
133 
134  unordered_set&
135  operator=(initializer_list<value_type> __l)
136  {
137  this->_M_profile_destruct();
138  _M_base() = __l;
139  this->_M_profile_construct();
140  return *this;
141  }
142 
143  void
144  swap(unordered_set& __x)
145  noexcept( noexcept(__x._M_base().swap(__x)) )
146  {
147  _Base::swap(__x);
148  this->_M_swap(__x);
149  }
150 
151  void
152  clear() noexcept
153  {
154  this->_M_profile_destruct();
155  _Base::clear();
156  this->_M_profile_construct();
157  }
158 
159  template<typename... _Args>
160  std::pair<iterator, bool>
161  emplace(_Args&&... __args)
162  {
163  size_type __old_size = _Base::bucket_count();
164  std::pair<iterator, bool> __res
165  = _Base::emplace(std::forward<_Args>(__args)...);
166  this->_M_profile_resize(__old_size);
167  return __res;
168  }
169 
170  template<typename... _Args>
171  iterator
172  emplace_hint(const_iterator __it, _Args&&... __args)
173  {
174  size_type __old_size = _Base::bucket_count();
175  iterator __res
176  = _Base::emplace_hint(__it, std::forward<_Args>(__args)...);
177  this->_M_profile_resize(__old_size);
178  return __res;
179  }
180 
181  void
182  insert(std::initializer_list<value_type> __l)
183  {
184  size_type __old_size = _Base::bucket_count();
185  _Base::insert(__l);
186  this->_M_profile_resize(__old_size);
187  }
188 
189  std::pair<iterator, bool>
190  insert(const value_type& __obj)
191  {
192  size_type __old_size = _Base::bucket_count();
193  std::pair<iterator, bool> __res = _Base::insert(__obj);
194  this->_M_profile_resize(__old_size);
195  return __res;
196  }
197 
198  iterator
199  insert(const_iterator __iter, const value_type& __v)
200  {
201  size_type __old_size = _Base::bucket_count();
202  iterator __res = _Base::insert(__iter, __v);
203  this->_M_profile_resize(__old_size);
204  return __res;
205  }
206 
207  std::pair<iterator, bool>
208  insert(value_type&& __obj)
209  {
210  size_type __old_size = _Base::bucket_count();
211  std::pair<iterator, bool> __res = _Base::insert(std::move(__obj));
212  this->_M_profile_resize(__old_size);
213  return __res;
214  }
215 
216  iterator
217  insert(const_iterator __iter, value_type&& __v)
218  {
219  size_type __old_size = _Base::bucket_count();
220  iterator __res = _Base::insert(__iter, std::move(__v));
221  this->_M_profile_resize(__old_size);
222  return __res;
223  }
224 
225  template<typename _InputIter>
226  void
227  insert(_InputIter __first, _InputIter __last)
228  {
229  size_type __old_size = _Base::bucket_count();
230  _Base::insert(__first, __last);
231  this->_M_profile_resize(__old_size);
232  }
233 
234  void
235  rehash(size_type __n)
236  {
237  size_type __old_size = _Base::bucket_count();
238  _Base::rehash(__n);
239  this->_M_profile_resize(__old_size);
240  }
241  };
242 
243  template<typename _Key, typename _Hash, typename _Pred, typename _Alloc>
244  inline void
245  swap(unordered_set<_Key, _Hash, _Pred, _Alloc>& __x,
246  unordered_set<_Key, _Hash, _Pred, _Alloc>& __y)
247  { __x.swap(__y); }
248 
249  template<typename _Key, typename _Hash, typename _Pred, typename _Alloc>
250  inline bool
251  operator==(const unordered_set<_Key, _Hash, _Pred, _Alloc>& __x,
252  const unordered_set<_Key, _Hash, _Pred, _Alloc>& __y)
253  { return static_cast<const _GLIBCXX_STD_BASE&>(__x) == __y; }
254 
255  template<typename _Key, typename _Hash, typename _Pred, typename _Alloc>
256  inline bool
257  operator!=(const unordered_set<_Key, _Hash, _Pred, _Alloc>& __x,
258  const unordered_set<_Key, _Hash, _Pred, _Alloc>& __y)
259  { return !(__x == __y); }
260 
261 #undef _GLIBCXX_BASE
262 #undef _GLIBCXX_STD_BASE
263 #define _GLIBCXX_STD_BASE _GLIBCXX_STD_C::_GLIBCXX_BASE
264 #define _GLIBCXX_BASE unordered_multiset<_Value, _Hash, _Pred, _Alloc>
265 
266  /** @brief Unordered_multiset wrapper with performance instrumentation. */
267  template<typename _Value,
268  typename _Hash = std::hash<_Value>,
269  typename _Pred = std::equal_to<_Value>,
270  typename _Alloc = std::allocator<_Value> >
271  class unordered_multiset
272  : public _GLIBCXX_STD_BASE,
273  public _Unordered_profile<unordered_multiset<_Value,
274  _Hash, _Pred, _Alloc>,
275  false>
276  {
277  typedef _GLIBCXX_STD_BASE _Base;
278 
279  _Base&
280  _M_base() noexcept { return *this; }
281 
282  const _Base&
283  _M_base() const noexcept { return *this; }
284 
285  public:
286  typedef typename _Base::size_type size_type;
287  typedef typename _Base::hasher hasher;
288  typedef typename _Base::key_equal key_equal;
289  typedef typename _Base::allocator_type allocator_type;
290  typedef typename _Base::key_type key_type;
291  typedef typename _Base::value_type value_type;
292  typedef typename _Base::difference_type difference_type;
293  typedef typename _Base::reference reference;
294  typedef typename _Base::const_reference const_reference;
295 
296  typedef typename _Base::iterator iterator;
297  typedef typename _Base::const_iterator const_iterator;
298 
299  unordered_multiset() = default;
300 
301  explicit
302  unordered_multiset(size_type __n,
303  const hasher& __hf = hasher(),
304  const key_equal& __eql = key_equal(),
305  const allocator_type& __a = allocator_type())
306  : _Base(__n, __hf, __eql, __a)
307  { }
308 
309  template<typename _InputIterator>
310  unordered_multiset(_InputIterator __f, _InputIterator __l,
311  size_type __n = 0,
312  const hasher& __hf = hasher(),
313  const key_equal& __eql = key_equal(),
314  const allocator_type& __a = allocator_type())
315  : _Base(__f, __l, __n, __hf, __eql, __a)
316  { }
317 
318  unordered_multiset(const unordered_multiset&) = default;
319 
320  unordered_multiset(const _Base& __x)
321  : _Base(__x)
322  { }
323 
324  unordered_multiset(unordered_multiset&&) = default;
325 
326  explicit
327  unordered_multiset(const allocator_type& __a)
328  : _Base(__a)
329  { }
330 
331  unordered_multiset(const unordered_multiset& __umset,
332  const allocator_type& __a)
333  : _Base(__umset._M_base(), __a)
334  { }
335 
336  unordered_multiset(unordered_multiset&& __umset,
337  const allocator_type& __a)
338  : _Base(std::move(__umset._M_base()), __a)
339  { }
340 
341  unordered_multiset(initializer_list<value_type> __l,
342  size_type __n = 0,
343  const hasher& __hf = hasher(),
344  const key_equal& __eql = key_equal(),
345  const allocator_type& __a = allocator_type())
346  : _Base(__l, __n, __hf, __eql, __a)
347  { }
348 
349  unordered_multiset&
350  operator=(const unordered_multiset&) = default;
351 
352  unordered_multiset&
353  operator=(unordered_multiset&&) = default;
354 
355  unordered_multiset&
356  operator=(initializer_list<value_type> __l)
357  {
358  this->_M_profile_destruct();
359  _M_base() = __l;
360  this->_M_profile_construct();
361  return *this;
362  }
363 
364  void
365  swap(unordered_multiset& __x)
366  noexcept( noexcept(__x._M_base().swap(__x)) )
367  {
368  _Base::swap(__x);
369  this->_M_swap(__x);
370  }
371 
372  void
373  clear() noexcept
374  {
375  this->_M_profile_destruct();
376  _Base::clear();
377  this->_M_profile_construct();
378  }
379 
380  template<typename... _Args>
381  iterator
382  emplace(_Args&&... __args)
383  {
384  size_type __old_size = _Base::bucket_count();
385  iterator __res = _Base::emplace(std::forward<_Args>(__args)...);
386  this->_M_profile_resize(__old_size);
387  return __res;
388  }
389 
390  template<typename... _Args>
391  iterator
392  emplace_hint(const_iterator __it, _Args&&... __args)
393  {
394  size_type __old_size = _Base::bucket_count();
395  iterator __res
396  = _Base::emplace_hint(__it, std::forward<_Args>(__args)...);
397  this->_M_profile_resize(__old_size);
398  return __res;
399  }
400 
401  void
402  insert(std::initializer_list<value_type> __l)
403  {
404  size_type __old_size = _Base::bucket_count();
405  _Base::insert(__l);
406  this->_M_profile_resize(__old_size);
407  }
408 
409  iterator
410  insert(const value_type& __obj)
411  {
412  size_type __old_size = _Base::bucket_count();
413  iterator __res = _Base::insert(__obj);
414  this->_M_profile_resize(__old_size);
415  return __res;
416  }
417 
418  iterator
419  insert(const_iterator __iter, const value_type& __v)
420  {
421  size_type __old_size = _Base::bucket_count();
422  iterator __res = _Base::insert(__iter, __v);
423  this->_M_profile_resize(__old_size);
424  return __res;
425  }
426 
427  iterator
428  insert(value_type&& __obj)
429  {
430  size_type __old_size = _Base::bucket_count();
431  iterator __res = _Base::insert(std::move(__obj));
432  this->_M_profile_resize(__old_size);
433  return __res;
434  }
435 
436  iterator
437  insert(const_iterator __iter, value_type&& __v)
438  {
439  size_type __old_size = _Base::bucket_count();
440  iterator __res = _Base::insert(__iter, std::move(__v));
441  this->_M_profile_resize(__old_size);
442  return __res;
443  }
444 
445  template<typename _InputIter>
446  void
447  insert(_InputIter __first, _InputIter __last)
448  {
449  size_type __old_size = _Base::bucket_count();
450  _Base::insert(__first, __last);
451  this->_M_profile_resize(__old_size);
452  }
453 
454  void
455  rehash(size_type __n)
456  {
457  size_type __old_size = _Base::bucket_count();
458  _Base::rehash(__n);
459  this->_M_profile_resize(__old_size);
460  }
461  };
462 
463  template<typename _Value, typename _Hash, typename _Pred, typename _Alloc>
464  inline void
465  swap(unordered_multiset<_Value, _Hash, _Pred, _Alloc>& __x,
466  unordered_multiset<_Value, _Hash, _Pred, _Alloc>& __y)
467  { __x.swap(__y); }
468 
469  template<typename _Value, typename _Hash, typename _Pred, typename _Alloc>
470  inline bool
471  operator==(const unordered_multiset<_Value, _Hash, _Pred, _Alloc>& __x,
472  const unordered_multiset<_Value, _Hash, _Pred, _Alloc>& __y)
473  { return static_cast<const _GLIBCXX_STD_BASE&>(__x) == __y; }
474 
475  template<typename _Value, typename _Hash, typename _Pred, typename _Alloc>
476  inline bool
477  operator!=(const unordered_multiset<_Value, _Hash, _Pred, _Alloc>& __x,
478  const unordered_multiset<_Value, _Hash, _Pred, _Alloc>& __y)
479  { return !(__x == __y); }
480 
481 } // namespace __profile
482 } // namespace std
483 
484 #undef _GLIBCXX_BASE
485 #undef _GLIBCXX_STD_BASE
486 
487 #endif // C++11
488 
489 #endif