libstdc++
profile/map.h
Go to the documentation of this file.
1 // Profiling map implementation -*- C++ -*-
2 
3 // Copyright (C) 2009-2017 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/map.h
25  * This file is a GNU profile extension to the Standard C++ Library.
26  */
27 
28 #ifndef _GLIBCXX_PROFILE_MAP_H
29 #define _GLIBCXX_PROFILE_MAP_H 1
30 
31 #include <profile/base.h>
32 #include <profile/ordered_base.h>
33 
34 namespace std _GLIBCXX_VISIBILITY(default)
35 {
36 namespace __profile
37 {
38  /// Class std::map wrapper with performance instrumentation.
39  template<typename _Key, typename _Tp, typename _Compare = std::less<_Key>,
40  typename _Allocator = std::allocator<std::pair<const _Key, _Tp> > >
41  class map
42  : public _GLIBCXX_STD_C::map<_Key, _Tp, _Compare, _Allocator>,
43  public _Ordered_profile<map<_Key, _Tp, _Compare, _Allocator> >
44  {
45  typedef _GLIBCXX_STD_C::map<_Key, _Tp, _Compare, _Allocator> _Base;
46 
47  typedef typename _Base::iterator _Base_iterator;
48  typedef typename _Base::const_iterator _Base_const_iterator;
49 
50  public:
51  // types:
52  typedef _Key key_type;
53  typedef _Tp mapped_type;
54  typedef typename _Base::value_type value_type;
55  typedef _Compare key_compare;
56  typedef typename _Base::reference reference;
57  typedef typename _Base::const_reference const_reference;
58 
59  typedef __iterator_tracker<_Base_iterator, map> iterator;
60  typedef __iterator_tracker<_Base_const_iterator,
61  map> const_iterator;
62  typedef std::reverse_iterator<iterator> reverse_iterator;
63  typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
64 
65  typedef typename _Base::size_type size_type;
66  typedef typename _Base::difference_type difference_type;
67 
68  // 23.3.1.1 construct/copy/destroy:
69 
70 #if __cplusplus < 201103L
71  map()
72  : _Base() { }
73  map(const map& __x)
74  : _Base(__x) { }
75  ~map()
76  { }
77 #else
78  map() = default;
79  map(const map&) = default;
80  map(map&&) = default;
81  ~map() = default;
82 #endif
83 
84  explicit
85  map(const _Compare& __comp,
86  const _Allocator& __a = _Allocator())
87  : _Base(__comp, __a) { }
88 
89 #if __cplusplus >= 201103L
90  template<typename _InputIterator,
91  typename = std::_RequireInputIter<_InputIterator>>
92 #else
93  template<typename _InputIterator>
94 #endif
95  map(_InputIterator __first, _InputIterator __last,
96  const _Compare& __comp = _Compare(),
97  const _Allocator& __a = _Allocator())
98  : _Base(__first, __last, __comp, __a) { }
99 
100  map(const _Base& __x)
101  : _Base(__x) { }
102 
103 #if __cplusplus >= 201103L
104  map(initializer_list<value_type> __l,
105  const _Compare& __c = _Compare(),
106  const _Allocator& __a = _Allocator())
107  : _Base(__l, __c, __a) { }
108 
109  explicit
110  map(const _Allocator& __a)
111  : _Base(__a) { }
112 
113  map(const map& __x, const _Allocator& __a)
114  : _Base(__x, __a) { }
115 
116  map(map&& __x, const _Allocator& __a)
117  noexcept( noexcept(_Base(std::move(__x), __a)) )
118  : _Base(std::move(__x), __a) { }
119 
120  map(initializer_list<value_type> __l, const _Allocator& __a)
121  : _Base(__l, __a) { }
122 
123  template<typename _InputIterator>
124  map(_InputIterator __first, _InputIterator __last,
125  const _Allocator& __a)
126  : _Base(__first, __last, __a) { }
127 #endif
128 
129 #if __cplusplus < 201103L
130  map&
131  operator=(const map& __x)
132  {
133  this->_M_profile_destruct();
134  _M_base() = __x;
135  this->_M_profile_construct();
136  return *this;
137  }
138 #else
139  map&
140  operator=(const map&) = default;
141 
142  map&
143  operator=(map&&) = default;
144 
145  map&
146  operator=(initializer_list<value_type> __l)
147  {
148  this->_M_profile_destruct();
149  _M_base() = __l;
150  this->_M_profile_construct();
151  return *this;
152  }
153 #endif
154 
155  // iterators
156  iterator
157  begin() _GLIBCXX_NOEXCEPT
158  { return iterator(_Base::begin(), this); }
159 
160  const_iterator
161  begin() const _GLIBCXX_NOEXCEPT
162  { return const_iterator(_Base::begin(), this); }
163 
164  iterator
165  end() _GLIBCXX_NOEXCEPT
166  { return iterator(_Base::end(), this); }
167 
168  const_iterator
169  end() const _GLIBCXX_NOEXCEPT
170  { return const_iterator(_Base::end(), this); }
171 
172 #if __cplusplus >= 201103L
173  const_iterator
174  cbegin() const noexcept
175  { return const_iterator(_Base::cbegin(), this); }
176 
177  const_iterator
178  cend() const noexcept
179  { return const_iterator(_Base::cend(), this); }
180 #endif
181 
182  reverse_iterator
183  rbegin() _GLIBCXX_NOEXCEPT
184  {
185  __profcxx_map2umap_invalidate(this->_M_map2umap_info);
186  return reverse_iterator(end());
187  }
188 
189  const_reverse_iterator
190  rbegin() const _GLIBCXX_NOEXCEPT
191  {
192  __profcxx_map2umap_invalidate(this->_M_map2umap_info);
193  return const_reverse_iterator(end());
194  }
195 
196  reverse_iterator
197  rend() _GLIBCXX_NOEXCEPT
198  {
199  __profcxx_map2umap_invalidate(this->_M_map2umap_info);
200  return reverse_iterator(begin());
201  }
202 
203  const_reverse_iterator
204  rend() const _GLIBCXX_NOEXCEPT
205  {
206  __profcxx_map2umap_invalidate(this->_M_map2umap_info);
207  return const_reverse_iterator(begin());
208  }
209 
210 #if __cplusplus >= 201103L
211  const_reverse_iterator
212  crbegin() const noexcept
213  {
214  __profcxx_map2umap_invalidate(this->_M_map2umap_info);
215  return const_reverse_iterator(cend());
216  }
217 
218  const_reverse_iterator
219  crend() const noexcept
220  {
221  __profcxx_map2umap_invalidate(this->_M_map2umap_info);
222  return const_reverse_iterator(cbegin());
223  }
224 #endif
225 
226  // 23.3.1.2 element access:
227  mapped_type&
228  operator[](const key_type& __k)
229  {
230  __profcxx_map2umap_find(this->_M_map2umap_info, this->size());
231  return _Base::operator[](__k);
232  }
233 
234 #if __cplusplus >= 201103L
235  mapped_type&
236  operator[](key_type&& __k)
237  {
238  __profcxx_map2umap_find(this->_M_map2umap_info, this->size());
239  return _Base::operator[](std::move(__k));
240  }
241 #endif
242 
243  mapped_type&
244  at(const key_type& __k)
245  {
246  __profcxx_map2umap_find(this->_M_map2umap_info, this->size());
247  return _Base::at(__k);
248  }
249 
250  const mapped_type&
251  at(const key_type& __k) const
252  {
253  __profcxx_map2umap_find(this->_M_map2umap_info, this->size());
254  return _Base::at(__k);
255  }
256 
257  // modifiers:
258 #if __cplusplus >= 201103L
259  template<typename... _Args>
260  std::pair<iterator, bool>
261  emplace(_Args&&... __args)
262  {
263  // The cost is the same whether or not the element is inserted so we
264  // always report insertion of 1 element.
265  __profcxx_map2umap_insert(this->_M_map2umap_info, this->size(), 1);
266  auto __base_ret = _Base::emplace(std::forward<_Args>(__args)...);
267  return std::make_pair(iterator(__base_ret.first, this),
268  __base_ret.second);
269  }
270 
271  template<typename... _Args>
272  iterator
273  emplace_hint(const_iterator __pos, _Args&&... __args)
274  {
275  auto size_before = this->size();
276  auto __res
277  = _Base::emplace_hint(__pos.base(), std::forward<_Args>(__args)...);
278  __profcxx_map2umap_insert(this->_M_map2umap_info,
279  size_before, _M_hint_used(__pos.base(), __res) ? 0 : 1);
280  return iterator(__res, this);
281  }
282 #endif
283 
284  std::pair<iterator, bool>
285  insert(const value_type& __x)
286  {
287  __profcxx_map2umap_insert(this->_M_map2umap_info, this->size(), 1);
288  std::pair<_Base_iterator, bool> __base_ret = _Base::insert(__x);
289  return std::make_pair(iterator(__base_ret.first, this),
290  __base_ret.second);
291  }
292 
293 #if __cplusplus >= 201103L
294  template<typename _Pair, typename = typename
295  std::enable_if<std::is_constructible<value_type,
296  _Pair&&>::value>::type>
297  std::pair<iterator, bool>
298  insert(_Pair&& __x)
299  {
300  __profcxx_map2umap_insert(this->_M_map2umap_info, this->size(), 1);
301  auto __base_ret= _Base::insert(std::forward<_Pair>(__x));
302  return std::make_pair(iterator(__base_ret.first, this),
303  __base_ret.second);
304  }
305 #endif
306 
307 #if __cplusplus >= 201103L
308  void
309  insert(std::initializer_list<value_type> __list)
310  { insert(__list.begin(), __list.end()); }
311 #endif
312 
313  iterator
314 #if __cplusplus >= 201103L
315  insert(const_iterator __pos, const value_type& __x)
316 #else
317  insert(iterator __pos, const value_type& __x)
318 #endif
319  {
320  size_type size_before = this->size();
321  _Base_iterator __res = _Base::insert(__pos.base(), __x);
322 
323  __profcxx_map2umap_insert(this->_M_map2umap_info,
324  size_before, _M_hint_used(__pos.base(), __res) ? 0 : 1);
325  return iterator(__res, this);
326  }
327 
328 #if __cplusplus >= 201103L
329  template<typename _Pair, typename = typename
330  std::enable_if<std::is_constructible<value_type,
331  _Pair&&>::value>::type>
332  iterator
333  insert(const_iterator __pos, _Pair&& __x)
334  {
335  size_type size_before = this->size();
336  auto __res = _Base::insert(__pos.base(), std::forward<_Pair>(__x));
337 
338  __profcxx_map2umap_insert(this->_M_map2umap_info,
339  size_before, _M_hint_used(__pos.base(), __res) ? 0 : 1);
340  return iterator(__res, this);
341  }
342 #endif
343 
344  template<typename _InputIterator>
345  void
346  insert(_InputIterator __first, _InputIterator __last)
347  {
348  for (; __first != __last; ++__first)
349  insert(*__first);
350  }
351 
352 #if __cplusplus >= 201103L
353  iterator
354  erase(const_iterator __pos)
355  {
356  __profcxx_map2umap_erase(this->_M_map2umap_info, this->size(), 1);
357  return iterator(_Base::erase(__pos.base()), this);
358  }
359 
360  iterator
361  erase(iterator __pos)
362  {
363  __profcxx_map2umap_erase(this->_M_map2umap_info, this->size(), 1);
364  return iterator(_Base::erase(__pos.base()), this);
365  }
366 #else
367  void
368  erase(iterator __pos)
369  {
370  __profcxx_map2umap_erase(this->_M_map2umap_info, this->size(), 1);
371  _Base::erase(__pos.base());
372  }
373 #endif
374 
375  size_type
376  erase(const key_type& __x)
377  {
378  __profcxx_map2umap_find(this->_M_map2umap_info, this->size());
379  __profcxx_map2umap_erase(this->_M_map2umap_info, this->size(), 1);
380  return _Base::erase(__x);
381  }
382 
383 #if __cplusplus >= 201103L
384  iterator
385  erase(const_iterator __first, const_iterator __last)
386  {
387  if (__first != __last)
388  {
389  iterator __ret;
390  for (; __first != __last;)
391  __ret = erase(__first++);
392  return __ret;
393  }
394  else
395  return iterator(_Base::erase(__first.base(), __last.base()), this);
396  }
397 #else
398  void
399  erase(iterator __first, iterator __last)
400  {
401  for (; __first != __last;)
402  erase(__first++);
403  }
404 #endif
405 
406  void
407  swap(map& __x)
408  _GLIBCXX_NOEXCEPT_IF( noexcept(declval<_Base&>().swap(__x)) )
409  {
410  _Base::swap(__x);
411  this->_M_swap(__x);
412  }
413 
414  void
415  clear() _GLIBCXX_NOEXCEPT
416  {
417  this->_M_profile_destruct();
418  _Base::clear();
419  this->_M_profile_construct();
420  }
421 
422  // 23.3.1.3 map operations:
423  iterator
424  find(const key_type& __x)
425  {
426  __profcxx_map2umap_find(this->_M_map2umap_info, this->size());
427  return iterator(_Base::find(__x), this);
428  }
429 
430 #if __cplusplus > 201103L
431  template<typename _Kt,
432  typename _Req =
433  typename __has_is_transparent<_Compare, _Kt>::type>
434  iterator
435  find(const _Kt& __x)
436  {
437  __profcxx_map2umap_find(this->_M_map2umap_info, this->size());
438  return { _Base::find(__x), this };
439  }
440 #endif
441 
442  const_iterator
443  find(const key_type& __x) const
444  {
445  __profcxx_map2umap_find(this->_M_map2umap_info, this->size());
446  return const_iterator(_Base::find(__x), this);
447  }
448 
449 #if __cplusplus > 201103L
450  template<typename _Kt,
451  typename _Req =
452  typename __has_is_transparent<_Compare, _Kt>::type>
453  const_iterator
454  find(const _Kt& __x) const
455  {
456  __profcxx_map2umap_find(this->_M_map2umap_info, this->size());
457  return { _Base::find(__x), this };
458  }
459 #endif
460 
461  size_type
462  count(const key_type& __x) const
463  {
464  __profcxx_map2umap_find(this->_M_map2umap_info, this->size());
465  return _Base::count(__x);
466  }
467 
468 #if __cplusplus > 201103L
469  template<typename _Kt,
470  typename _Req =
471  typename __has_is_transparent<_Compare, _Kt>::type>
472  size_type
473  count(const _Kt& __x) const
474  {
475  __profcxx_map2umap_find(this->_M_map2umap_info, this->size());
476  return _Base::count(__x);
477  }
478 #endif
479 
480  iterator
481  lower_bound(const key_type& __x)
482  {
483  __profcxx_map2umap_find(this->_M_map2umap_info, this->size());
484  __profcxx_map2umap_invalidate(this->_M_map2umap_info);
485  return iterator(_Base::lower_bound(__x), this);
486  }
487 
488 #if __cplusplus > 201103L
489  template<typename _Kt,
490  typename _Req =
491  typename __has_is_transparent<_Compare, _Kt>::type>
492  iterator
493  lower_bound(const _Kt& __x)
494  {
495  __profcxx_map2umap_find(this->_M_map2umap_info, this->size());
496  __profcxx_map2umap_invalidate(this->_M_map2umap_info);
497  return { _Base::lower_bound(__x), this };
498  }
499 #endif
500 
501  const_iterator
502  lower_bound(const key_type& __x) const
503  {
504  __profcxx_map2umap_find(this->_M_map2umap_info, this->size());
505  __profcxx_map2umap_invalidate(this->_M_map2umap_info);
506  return const_iterator(_Base::lower_bound(__x), this);
507  }
508 
509 #if __cplusplus > 201103L
510  template<typename _Kt,
511  typename _Req =
512  typename __has_is_transparent<_Compare, _Kt>::type>
513  const_iterator
514  lower_bound(const _Kt& __x) const
515  {
516  __profcxx_map2umap_find(this->_M_map2umap_info, this->size());
517  __profcxx_map2umap_invalidate(this->_M_map2umap_info);
518  return { _Base::lower_bound(__x), this };
519  }
520 #endif
521 
522  iterator
523  upper_bound(const key_type& __x)
524  {
525  __profcxx_map2umap_find(this->_M_map2umap_info, this->size());
526  __profcxx_map2umap_invalidate(this->_M_map2umap_info);
527  return iterator(_Base::upper_bound(__x), this);
528  }
529 
530 #if __cplusplus > 201103L
531  template<typename _Kt,
532  typename _Req =
533  typename __has_is_transparent<_Compare, _Kt>::type>
534  iterator
535  upper_bound(const _Kt& __x)
536  {
537  __profcxx_map2umap_find(this->_M_map2umap_info, this->size());
538  __profcxx_map2umap_invalidate(this->_M_map2umap_info);
539  return { _Base::upper_bound(__x), this };
540  }
541 #endif
542 
543  const_iterator
544  upper_bound(const key_type& __x) const
545  {
546  __profcxx_map2umap_find(this->_M_map2umap_info, this->size());
547  __profcxx_map2umap_invalidate(this->_M_map2umap_info);
548  return const_iterator(_Base::upper_bound(__x), this);
549  }
550 
551 #if __cplusplus > 201103L
552  template<typename _Kt,
553  typename _Req =
554  typename __has_is_transparent<_Compare, _Kt>::type>
555  const_iterator
556  upper_bound(const _Kt& __x) const
557  {
558  __profcxx_map2umap_find(this->_M_map2umap_info, this->size());
559  __profcxx_map2umap_invalidate(this->_M_map2umap_info);
560  return { _Base::upper_bound(__x), this };
561  }
562 #endif
563 
564  std::pair<iterator,iterator>
565  equal_range(const key_type& __x)
566  {
567  __profcxx_map2umap_find(this->_M_map2umap_info, this->size());
568  std::pair<_Base_iterator, _Base_iterator> __base_ret
569  = _Base::equal_range(__x);
570  return std::make_pair(iterator(__base_ret.first, this),
571  iterator(__base_ret.second, this));
572  }
573 
574 #if __cplusplus > 201103L
575  template<typename _Kt,
576  typename _Req =
577  typename __has_is_transparent<_Compare, _Kt>::type>
578  std::pair<iterator, iterator>
579  equal_range(const _Kt& __x)
580  {
581  __profcxx_map2umap_find(this->_M_map2umap_info, this->size());
582  auto __res = _Base::equal_range(__x);
583  return { { __res.first, this }, { __res.second, this } };
584  }
585 #endif
586 
587  std::pair<const_iterator,const_iterator>
588  equal_range(const key_type& __x) const
589  {
590  __profcxx_map2umap_find(this->_M_map2umap_info, this->size());
591  std::pair<_Base_const_iterator, _Base_const_iterator> __base_ret
592  = _Base::equal_range(__x);
593  return std::make_pair(const_iterator(__base_ret.first, this),
594  const_iterator(__base_ret.second, this));
595  }
596 
597 #if __cplusplus > 201103L
598  template<typename _Kt,
599  typename _Req =
600  typename __has_is_transparent<_Compare, _Kt>::type>
601  std::pair<const_iterator, const_iterator>
602  equal_range(const _Kt& __x) const
603  {
604  __profcxx_map2umap_find(this->_M_map2umap_info, this->size());
605  auto __res = _Base::equal_range(__x);
606  return { { __res.first, this }, { __res.second, this } };
607  }
608 #endif
609 
610  _Base&
611  _M_base() _GLIBCXX_NOEXCEPT { return *this; }
612 
613  const _Base&
614  _M_base() const _GLIBCXX_NOEXCEPT { return *this; }
615 
616  private:
617  /** If hint is used we consider that the map and unordered_map
618  * operations have equivalent insertion cost so we do not update metrics
619  * about it.
620  * Note that to find out if hint has been used is libstdc++
621  * implementation dependent.
622  */
623  bool
624  _M_hint_used(_Base_const_iterator __hint, _Base_iterator __res)
625  {
626  return (__hint == __res
627  || (__hint == _M_base().end() && ++__res == _M_base().end())
628  || (__hint != _M_base().end() && (++__hint == __res
629  || ++__res == --__hint)));
630  }
631 
632 
633  template<typename _K1, typename _T1, typename _C1, typename _A1>
634  friend bool
635  operator==(const map<_K1, _T1, _C1, _A1>&,
636  const map<_K1, _T1, _C1, _A1>&);
637 
638  template<typename _K1, typename _T1, typename _C1, typename _A1>
639  friend bool
640  operator<(const map<_K1, _T1, _C1, _A1>&,
641  const map<_K1, _T1, _C1, _A1>&);
642  };
643 
644  template<typename _Key, typename _Tp,
645  typename _Compare, typename _Allocator>
646  inline bool
647  operator==(const map<_Key, _Tp, _Compare, _Allocator>& __lhs,
648  const map<_Key, _Tp, _Compare, _Allocator>& __rhs)
649  {
650  __profcxx_map2umap_invalidate(__lhs._M_map2umap_info);
651  __profcxx_map2umap_invalidate(__rhs._M_map2umap_info);
652  return __lhs._M_base() == __rhs._M_base();
653  }
654 
655  template<typename _Key, typename _Tp,
656  typename _Compare, typename _Allocator>
657  inline bool
658  operator<(const map<_Key, _Tp, _Compare, _Allocator>& __lhs,
659  const map<_Key, _Tp, _Compare, _Allocator>& __rhs)
660  {
661  __profcxx_map2umap_invalidate(__lhs._M_map2umap_info);
662  __profcxx_map2umap_invalidate(__rhs._M_map2umap_info);
663  return __lhs._M_base() < __rhs._M_base();
664  }
665 
666  template<typename _Key, typename _Tp,
667  typename _Compare, typename _Allocator>
668  inline bool
669  operator!=(const map<_Key, _Tp, _Compare, _Allocator>& __lhs,
670  const map<_Key, _Tp, _Compare, _Allocator>& __rhs)
671  { return !(__lhs == __rhs); }
672 
673  template<typename _Key, typename _Tp,
674  typename _Compare, typename _Allocator>
675  inline bool
676  operator<=(const map<_Key, _Tp, _Compare, _Allocator>& __lhs,
677  const map<_Key, _Tp, _Compare, _Allocator>& __rhs)
678  { return !(__rhs < __lhs); }
679 
680  template<typename _Key, typename _Tp,
681  typename _Compare, typename _Allocator>
682  inline bool
683  operator>=(const map<_Key, _Tp, _Compare, _Allocator>& __lhs,
684  const map<_Key, _Tp, _Compare, _Allocator>& __rhs)
685  { return !(__lhs < __rhs); }
686 
687  template<typename _Key, typename _Tp,
688  typename _Compare, typename _Allocator>
689  inline bool
690  operator>(const map<_Key, _Tp, _Compare, _Allocator>& __lhs,
691  const map<_Key, _Tp, _Compare, _Allocator>& __rhs)
692  { return __rhs < __lhs; }
693 
694  template<typename _Key, typename _Tp,
695  typename _Compare, typename _Allocator>
696  inline void
697  swap(map<_Key, _Tp, _Compare, _Allocator>& __lhs,
698  map<_Key, _Tp, _Compare, _Allocator>& __rhs)
699  _GLIBCXX_NOEXCEPT_IF(noexcept(__lhs.swap(__rhs)))
700  { __lhs.swap(__rhs); }
701 
702 } // namespace __profile
703 } // namespace std
704 
705 #endif
std::pair::second
_T2 second
first is a copy of the first object
Definition: stl_pair.h:204
base.h
Sequential helper functions. This file is a GNU profile extension to the Standard C++ Library...
std::__profile::map
Class std::map wrapper with performance instrumentation.
Definition: profile/map.h:41
std::initializer_list
initializer_list
Definition: initializer_list:47
std::pair::first
_T1 first
second_type is the second bound type
Definition: stl_pair.h:203
std
ISO C++ entities toplevel namespace is std.
std::make_pair
constexpr pair< typename __decay_and_strip< _T1 >::__type, typename __decay_and_strip< _T2 >::__type > make_pair(_T1 &&__x, _T2 &&__y)
A convenience wrapper for creating a pair from two objects.
Definition: stl_pair.h:519
std::pair
Struct holding two objects of arbitrary type.
Definition: stl_pair.h:198