libstdc++
map.h
Go to the documentation of this file.
1 // Debugging map implementation -*- C++ -*-
2 
3 // Copyright (C) 2003-2025 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 and
21 // a copy of the GCC Runtime Library Exception along with this program;
22 // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
23 // <http://www.gnu.org/licenses/>.
24 
25 /** @file debug/map.h
26  * This file is a GNU debug extension to the Standard C++ Library.
27  */
28 
29 #ifndef _GLIBCXX_DEBUG_MAP_H
30 #define _GLIBCXX_DEBUG_MAP_H 1
31 
32 #include <debug/safe_sequence.h>
33 #include <debug/safe_container.h>
34 #include <debug/safe_iterator.h>
35 #include <bits/stl_pair.h>
36 
37 namespace std _GLIBCXX_VISIBILITY(default)
38 {
39 namespace __debug
40 {
41  /// Class std::map with safety/checking/debug instrumentation.
42  template<typename _Key, typename _Tp, typename _Compare = std::less<_Key>,
43  typename _Allocator = std::allocator<std::pair<const _Key, _Tp> > >
44  class map
46  map<_Key, _Tp, _Compare, _Allocator>, _Allocator,
47  __gnu_debug::_Safe_node_sequence>,
48  public _GLIBCXX_STD_C::map<_Key, _Tp, _Compare, _Allocator>
49  {
50  typedef _GLIBCXX_STD_C::map<
51  _Key, _Tp, _Compare, _Allocator> _Base;
54 
56  typedef typename _Base::iterator _Base_iterator;
58 
59  template<typename _ItT, typename _SeqT, typename _CatT>
60  friend class ::__gnu_debug::_Safe_iterator;
61 
62  // Reference wrapper for base class. Disambiguates map(const _Base&)
63  // from copy constructor by requiring a user-defined conversion.
64  // See PR libstdc++/90102.
65  struct _Base_ref
66  {
67  _Base_ref(const _Base& __r) : _M_ref(__r) { }
68 
69  const _Base& _M_ref;
70  };
71 
72  public:
73  // types:
74  typedef _Key key_type;
75  typedef _Tp mapped_type;
77  typedef _Compare key_compare;
78  typedef _Allocator allocator_type;
79  typedef typename _Base::reference reference;
80  typedef typename _Base::const_reference const_reference;
81 
83  iterator;
86 
87  typedef typename _Base::size_type size_type;
88  typedef typename _Base::difference_type difference_type;
89  typedef typename _Base::pointer pointer;
90  typedef typename _Base::const_pointer const_pointer;
93 
94  // 23.3.1.1 construct/copy/destroy:
95 
96 #if __cplusplus < 201103L
97  map() : _Base() { }
98 
99  map(const map& __x)
100  : _Base(__x) { }
101 
102  ~map() { }
103 #else
104  map() = default;
105  map(const map&) = default;
106  map(map&&) = default;
107 
109  const _Compare& __c = _Compare(),
110  const allocator_type& __a = allocator_type())
111  : _Base(__l, __c, __a) { }
112 
113  explicit
114  map(const allocator_type& __a)
115  : _Base(__a) { }
116 
117  map(const map& __m, const __type_identity_t<allocator_type>& __a)
118  : _Base(__m, __a) { }
119 
120  map(map&& __m, const __type_identity_t<allocator_type>& __a)
121  noexcept( noexcept(_Base(std::move(__m), __a)) )
122  : _Safe(std::move(__m), __a),
123  _Base(std::move(__m), __a) { }
124 
125  map(initializer_list<value_type> __l, const allocator_type& __a)
126  : _Base(__l, __a) { }
127 
128  template<typename _InputIterator>
129  map(_InputIterator __first, _InputIterator __last,
130  const allocator_type& __a)
132  __glibcxx_check_valid_constructor_range(__first, __last)),
133  __gnu_debug::__base(__last), __a)
134  { }
135 
136 #if __glibcxx_containers_ranges // C++ >= 23
137  /**
138  * @brief Construct a map from a range.
139  * @since C++23
140  */
141  template<std::__detail::__container_compatible_range<value_type> _Rg>
142  map(std::from_range_t __t, _Rg&& __rg,
143  const _Compare& __c,
144  const allocator_type& __a = allocator_type())
145  : _Base(__t, std::forward<_Rg>(__rg), __c, __a)
146  { }
147 
148  template<std::__detail::__container_compatible_range<value_type> _Rg>
149  map(std::from_range_t __t, _Rg&& __rg,
150  const allocator_type& __a = allocator_type())
151  : _Base(__t, std::forward<_Rg>(__rg), __a)
152  { }
153 #endif
154 
155  ~map() = default;
156 #endif
157 
158  map(_Base_ref __x)
159  : _Base(__x._M_ref) { }
160 
161  explicit map(const _Compare& __comp,
162  const _Allocator& __a = _Allocator())
163  : _Base(__comp, __a) { }
164 
165  template<typename _InputIterator>
166  map(_InputIterator __first, _InputIterator __last,
167  const _Compare& __comp = _Compare(),
168  const _Allocator& __a = _Allocator())
170  __glibcxx_check_valid_constructor_range(__first, __last)),
171  __gnu_debug::__base(__last),
172  __comp, __a) { }
173 
174 #if __cplusplus >= 201103L
175  map&
176  operator=(const map&) = default;
177 
178  map&
179  operator=(map&&) = default;
180 
181  map&
182  operator=(initializer_list<value_type> __l)
183  {
184  _Base::operator=(__l);
185  this->_M_invalidate_all();
186  return *this;
187  }
188 #endif
189 
190  // _GLIBCXX_RESOLVE_LIB_DEFECTS
191  // 133. map missing get_allocator()
192  using _Base::get_allocator;
193 
194  // iterators:
195  iterator
196  begin() _GLIBCXX_NOEXCEPT
197  { return iterator(_Base::begin(), this); }
198 
200  begin() const _GLIBCXX_NOEXCEPT
201  { return const_iterator(_Base::begin(), this); }
202 
203  iterator
204  end() _GLIBCXX_NOEXCEPT
205  { return iterator(_Base::end(), this); }
206 
208  end() const _GLIBCXX_NOEXCEPT
209  { return const_iterator(_Base::end(), this); }
210 
212  rbegin() _GLIBCXX_NOEXCEPT
213  { return reverse_iterator(end()); }
214 
216  rbegin() const _GLIBCXX_NOEXCEPT
217  { return const_reverse_iterator(end()); }
218 
220  rend() _GLIBCXX_NOEXCEPT
221  { return reverse_iterator(begin()); }
222 
224  rend() const _GLIBCXX_NOEXCEPT
225  { return const_reverse_iterator(begin()); }
226 
227 #if __cplusplus >= 201103L
229  cbegin() const noexcept
230  { return const_iterator(_Base::begin(), this); }
231 
233  cend() const noexcept
234  { return const_iterator(_Base::end(), this); }
235 
237  crbegin() const noexcept
238  { return const_reverse_iterator(end()); }
239 
241  crend() const noexcept
242  { return const_reverse_iterator(begin()); }
243 #endif
244 
245  // capacity:
246  using _Base::empty;
247  using _Base::size;
248  using _Base::max_size;
249 
250  // 23.3.1.2 element access:
251  using _Base::operator[];
252 
253  // _GLIBCXX_RESOLVE_LIB_DEFECTS
254  // DR 464. Suggestion for new member functions in standard containers.
255  using _Base::at;
256 
257  // modifiers:
258 #if __cplusplus >= 201103L
259  template<typename... _Args>
261  emplace(_Args&&... __args)
262  {
263  auto __res = _Base::emplace(std::forward<_Args>(__args)...);
264  return { { __res.first, this }, __res.second };
265  }
266 
267  template<typename... _Args>
268  iterator
269  emplace_hint(const_iterator __pos, _Args&&... __args)
270  {
271  __glibcxx_check_insert(__pos);
272  return
273  {
274  _Base::emplace_hint(__pos.base(), std::forward<_Args>(__args)...),
275  this
276  };
277  }
278 #endif
279 
281  insert(const value_type& __x)
282  {
283  std::pair<_Base_iterator, bool> __res = _Base::insert(__x);
284  return std::pair<iterator, bool>(iterator(__res.first, this),
285  __res.second);
286  }
287 
288 #if __cplusplus >= 201103L
289  // _GLIBCXX_RESOLVE_LIB_DEFECTS
290  // 2354. Unnecessary copying when inserting into maps with braced-init
292  insert(value_type&& __x)
293  {
294  auto __res = _Base::insert(std::move(__x));
295  return { { __res.first, this }, __res.second };
296  }
297 
298  template<typename _Pair, typename = typename
300  _Pair&&>::value>::type>
302  insert(_Pair&& __x)
303  {
304  auto __res = _Base::insert(std::forward<_Pair>(__x));
305  return { { __res.first, this }, __res.second };
306  }
307 #endif
308 
309 #if __cplusplus >= 201103L
310  void
311  insert(std::initializer_list<value_type> __list)
312  { _Base::insert(__list); }
313 #endif
314 
315  iterator
316 #if __cplusplus >= 201103L
317  insert(const_iterator __position, const value_type& __x)
318 #else
319  insert(iterator __position, const value_type& __x)
320 #endif
321  {
322  __glibcxx_check_insert(__position);
323  return iterator(_Base::insert(__position.base(), __x), this);
324  }
325 
326 #if __cplusplus >= 201103L
327  // _GLIBCXX_RESOLVE_LIB_DEFECTS
328  // 2354. Unnecessary copying when inserting into maps with braced-init
329  iterator
330  insert(const_iterator __position, value_type&& __x)
331  {
332  __glibcxx_check_insert(__position);
333  return { _Base::insert(__position.base(), std::move(__x)), this };
334  }
335 
336  template<typename _Pair, typename = typename
338  _Pair&&>::value>::type>
339  iterator
340  insert(const_iterator __position, _Pair&& __x)
341  {
342  __glibcxx_check_insert(__position);
343  return
344  {
345  _Base::insert(__position.base(), std::forward<_Pair>(__x)),
346  this
347  };
348  }
349 #endif
350 
351  template<typename _InputIterator>
352  void
353  insert(_InputIterator __first, _InputIterator __last)
354  {
356  __glibcxx_check_valid_range2(__first, __last, __dist);
357 
358  if (__dist.second >= __gnu_debug::__dp_sign)
359  _Base::insert(__gnu_debug::__unsafe(__first),
360  __gnu_debug::__unsafe(__last));
361  else
362  _Base::insert(__first, __last);
363  }
364 
365 
366 #ifdef __glibcxx_map_try_emplace // C++ >= 17 && HOSTED
367  template <typename... _Args>
369  try_emplace(const key_type& __k, _Args&&... __args)
370  {
371  auto __res = _Base::try_emplace(__k,
372  std::forward<_Args>(__args)...);
373  return { { __res.first, this }, __res.second };
374  }
375 
376  template <typename... _Args>
378  try_emplace(key_type&& __k, _Args&&... __args)
379  {
380  auto __res = _Base::try_emplace(std::move(__k),
381  std::forward<_Args>(__args)...);
382  return { { __res.first, this }, __res.second };
383  }
384 
385  template <typename... _Args>
386  iterator
387  try_emplace(const_iterator __hint, const key_type& __k,
388  _Args&&... __args)
389  {
390  __glibcxx_check_insert(__hint);
391  return
392  {
393  _Base::try_emplace(__hint.base(), __k,
394  std::forward<_Args>(__args)...),
395  this
396  };
397  }
398 
399  template <typename... _Args>
400  iterator
401  try_emplace(const_iterator __hint, key_type&& __k, _Args&&... __args)
402  {
403  __glibcxx_check_insert(__hint);
404  return
405  {
406  _Base::try_emplace(__hint.base(), std::move(__k),
407  std::forward<_Args>(__args)...),
408  this
409  };
410  }
411 
412  template <typename _Obj>
414  insert_or_assign(const key_type& __k, _Obj&& __obj)
415  {
416  auto __res = _Base::insert_or_assign(__k,
417  std::forward<_Obj>(__obj));
418  return { { __res.first, this }, __res.second };
419  }
420 
421  template <typename _Obj>
423  insert_or_assign(key_type&& __k, _Obj&& __obj)
424  {
425  auto __res = _Base::insert_or_assign(std::move(__k),
426  std::forward<_Obj>(__obj));
427  return { { __res.first, this }, __res.second };
428  }
429 
430  template <typename _Obj>
431  iterator
432  insert_or_assign(const_iterator __hint,
433  const key_type& __k, _Obj&& __obj)
434  {
435  __glibcxx_check_insert(__hint);
436  return
437  {
438  _Base::insert_or_assign(__hint.base(), __k,
439  std::forward<_Obj>(__obj)),
440  this
441  };
442  }
443 
444  template <typename _Obj>
445  iterator
446  insert_or_assign(const_iterator __hint, key_type&& __k, _Obj&& __obj)
447  {
448  __glibcxx_check_insert(__hint);
449  return
450  {
451  _Base::insert_or_assign(__hint.base(), std::move(__k),
452  std::forward<_Obj>(__obj)),
453  this
454  };
455  }
456 #endif // C++17
457 
458 #if __cplusplus > 201402L
459  using node_type = typename _Base::node_type;
461 
462  node_type
463  extract(const_iterator __position)
464  {
465  __glibcxx_check_erase(__position);
466  this->_M_invalidate_if(_Equal(__position.base()));
467  return _Base::extract(__position.base());
468  }
469 
470  node_type
471  extract(const key_type& __key)
472  {
473  const auto __position = find(__key);
474  if (__position != end())
475  return extract(__position);
476  return {};
477  }
478 
480  insert(node_type&& __nh)
481  {
482  auto __ret = _Base::insert(std::move(__nh));
483  return
484  { { __ret.position, this }, __ret.inserted, std::move(__ret.node) };
485  }
486 
487  iterator
488  insert(const_iterator __hint, node_type&& __nh)
489  {
490  __glibcxx_check_insert(__hint);
491  return { _Base::insert(__hint.base(), std::move(__nh)), this };
492  }
493 
494  using _Base::merge;
495 #endif // C++17
496 
497 #if __cplusplus >= 201103L
498  iterator
499  erase(const_iterator __position)
500  {
501  __glibcxx_check_erase(__position);
502  return { erase(__position.base()), this };
503  }
504 
506  erase(_Base_const_iterator __position)
507  {
508  __glibcxx_check_erase2(__position);
509  this->_M_invalidate_if(_Equal(__position));
510  return _Base::erase(__position);
511  }
512 
513  _GLIBCXX_ABI_TAG_CXX11
514  iterator
515  erase(iterator __position)
516  { return erase(const_iterator(__position)); }
517 #else
518  void
519  erase(iterator __position)
520  {
521  __glibcxx_check_erase(__position);
522  this->_M_invalidate_if(_Equal(__position.base()));
523  _Base::erase(__position.base());
524  }
525 #endif
526 
527  size_type
528  erase(const key_type& __x)
529  {
530  _Base_iterator __victim = _Base::find(__x);
531  if (__victim == _Base::end())
532  return 0;
533  else
534  {
535  this->_M_invalidate_if(_Equal(__victim));
536  _Base::erase(__victim);
537  return 1;
538  }
539  }
540 
541 #if __cplusplus >= 201103L
542  iterator
543  erase(const_iterator __first, const_iterator __last)
544  {
545  // _GLIBCXX_RESOLVE_LIB_DEFECTS
546  // 151. can't currently clear() empty container
547  __glibcxx_check_erase_range(__first, __last);
548  for (_Base_const_iterator __victim = __first.base();
549  __victim != __last.base(); ++__victim)
550  {
551  _GLIBCXX_DEBUG_VERIFY(__victim != _Base::cend(),
552  _M_message(__gnu_debug::__msg_valid_range)
553  ._M_iterator(__first, "first")
554  ._M_iterator(__last, "last"));
555  this->_M_invalidate_if(_Equal(__victim));
556  }
557 
558  return { _Base::erase(__first.base(), __last.base()), this };
559  }
560 #else
561  void
562  erase(iterator __first, iterator __last)
563  {
564  // _GLIBCXX_RESOLVE_LIB_DEFECTS
565  // 151. can't currently clear() empty container
566  __glibcxx_check_erase_range(__first, __last);
567  for (_Base_iterator __victim = __first.base();
568  __victim != __last.base(); ++__victim)
569  {
570  _GLIBCXX_DEBUG_VERIFY(__victim != _Base::end(),
571  _M_message(__gnu_debug::__msg_valid_range)
572  ._M_iterator(__first, "first")
573  ._M_iterator(__last, "last"));
574  this->_M_invalidate_if(_Equal(__victim));
575  }
576  _Base::erase(__first.base(), __last.base());
577  }
578 #endif
579 
580  void
581  swap(map& __x)
582  _GLIBCXX_NOEXCEPT_IF( noexcept(declval<_Base&>().swap(__x)) )
583  {
584  _Safe::_M_swap(__x);
585  _Base::swap(__x);
586  }
587 
588  void
589  clear() _GLIBCXX_NOEXCEPT
590  {
591  this->_M_invalidate_all();
592  _Base::clear();
593  }
594 
595  // observers:
596  using _Base::key_comp;
597  using _Base::value_comp;
598 
599  // 23.3.1.3 map operations:
600  iterator
601  find(const key_type& __x)
602  { return iterator(_Base::find(__x), this); }
603 
604 #if __cplusplus > 201103L
605  template<typename _Kt,
606  typename _Req =
607  typename __has_is_transparent<_Compare, _Kt>::type>
608  iterator
609  find(const _Kt& __x)
610  { return { _Base::find(__x), this }; }
611 #endif
612 
614  find(const key_type& __x) const
615  { return const_iterator(_Base::find(__x), this); }
616 
617 #if __cplusplus > 201103L
618  template<typename _Kt,
619  typename _Req =
620  typename __has_is_transparent<_Compare, _Kt>::type>
622  find(const _Kt& __x) const
623  { return { _Base::find(__x), this }; }
624 #endif
625 
626  using _Base::count;
627 
628  iterator
629  lower_bound(const key_type& __x)
630  { return iterator(_Base::lower_bound(__x), this); }
631 
632 #if __cplusplus > 201103L
633  template<typename _Kt,
634  typename _Req =
635  typename __has_is_transparent<_Compare, _Kt>::type>
636  iterator
637  lower_bound(const _Kt& __x)
638  { return { _Base::lower_bound(__x), this }; }
639 #endif
640 
642  lower_bound(const key_type& __x) const
643  { return const_iterator(_Base::lower_bound(__x), this); }
644 
645 #if __cplusplus > 201103L
646  template<typename _Kt,
647  typename _Req =
648  typename __has_is_transparent<_Compare, _Kt>::type>
650  lower_bound(const _Kt& __x) const
651  { return { _Base::lower_bound(__x), this }; }
652 #endif
653 
654  iterator
655  upper_bound(const key_type& __x)
656  { return iterator(_Base::upper_bound(__x), this); }
657 
658 #if __cplusplus > 201103L
659  template<typename _Kt,
660  typename _Req =
661  typename __has_is_transparent<_Compare, _Kt>::type>
662  iterator
663  upper_bound(const _Kt& __x)
664  { return { _Base::upper_bound(__x), this }; }
665 #endif
666 
668  upper_bound(const key_type& __x) const
669  { return const_iterator(_Base::upper_bound(__x), this); }
670 
671 #if __cplusplus > 201103L
672  template<typename _Kt,
673  typename _Req =
674  typename __has_is_transparent<_Compare, _Kt>::type>
676  upper_bound(const _Kt& __x) const
677  { return { _Base::upper_bound(__x), this }; }
678 #endif
679 
681  equal_range(const key_type& __x)
682  {
684  _Base::equal_range(__x);
685  return std::make_pair(iterator(__res.first, this),
686  iterator(__res.second, this));
687  }
688 
689 #if __cplusplus > 201103L
690  template<typename _Kt,
691  typename _Req =
692  typename __has_is_transparent<_Compare, _Kt>::type>
694  equal_range(const _Kt& __x)
695  {
696  auto __res = _Base::equal_range(__x);
697  return { { __res.first, this }, { __res.second, this } };
698  }
699 #endif
700 
702  equal_range(const key_type& __x) const
703  {
705  _Base::equal_range(__x);
706  return std::make_pair(const_iterator(__res.first, this),
707  const_iterator(__res.second, this));
708  }
709 
710 #if __cplusplus > 201103L
711  template<typename _Kt,
712  typename _Req =
713  typename __has_is_transparent<_Compare, _Kt>::type>
715  equal_range(const _Kt& __x) const
716  {
717  auto __res = _Base::equal_range(__x);
718  return { { __res.first, this }, { __res.second, this } };
719  }
720 #endif
721 
722  _Base&
723  _M_base() _GLIBCXX_NOEXCEPT { return *this; }
724 
725  const _Base&
726  _M_base() const _GLIBCXX_NOEXCEPT { return *this; }
727  };
728 
729 #if __cpp_deduction_guides >= 201606
730 
731  template<typename _InputIterator,
732  typename _Compare = less<__iter_key_t<_InputIterator>>,
733  typename _Allocator = allocator<__iter_to_alloc_t<_InputIterator>>,
734  typename = _RequireInputIter<_InputIterator>,
735  typename = _RequireNotAllocator<_Compare>,
736  typename = _RequireAllocator<_Allocator>>
737  map(_InputIterator, _InputIterator,
738  _Compare = _Compare(), _Allocator = _Allocator())
739  -> map<__iter_key_t<_InputIterator>, __iter_val_t<_InputIterator>,
740  _Compare, _Allocator>;
741 
742  template<typename _Key, typename _Tp, typename _Compare = less<_Key>,
743  typename _Allocator = allocator<pair<const _Key, _Tp>>,
744  typename = _RequireNotAllocator<_Compare>,
745  typename = _RequireAllocator<_Allocator>>
747  _Compare = _Compare(), _Allocator = _Allocator())
749 
750  template <typename _InputIterator, typename _Allocator,
751  typename = _RequireInputIter<_InputIterator>,
752  typename = _RequireAllocator<_Allocator>>
753  map(_InputIterator, _InputIterator, _Allocator)
754  -> map<__iter_key_t<_InputIterator>, __iter_val_t<_InputIterator>,
755  less<__iter_key_t<_InputIterator>>, _Allocator>;
756 
757  template<typename _Key, typename _Tp, typename _Allocator,
758  typename = _RequireAllocator<_Allocator>>
759  map(initializer_list<pair<_Key, _Tp>>, _Allocator)
760  -> map<_Key, _Tp, less<_Key>, _Allocator>;
761 
762 #if __glibcxx_containers_ranges // C++ >= 23
763  template<ranges::input_range _Rg,
764  __not_allocator_like _Compare = less<__detail::__range_key_type<_Rg>>,
765  __allocator_like _Alloc =
767  map(from_range_t, _Rg&&, _Compare = _Compare(), _Alloc = _Alloc())
769  __detail::__range_mapped_type<_Rg>,
770  _Compare, _Alloc>;
771 
772  template<ranges::input_range _Rg, __allocator_like _Alloc>
773  map(from_range_t, _Rg&&, _Alloc)
775  __detail::__range_mapped_type<_Rg>,
777  _Alloc>;
778 #endif
779 #endif // deduction guides
780 
781  template<typename _Key, typename _Tp,
782  typename _Compare, typename _Allocator>
783  inline bool
784  operator==(const map<_Key, _Tp, _Compare, _Allocator>& __lhs,
786  { return __lhs._M_base() == __rhs._M_base(); }
787 
788 #if __cpp_lib_three_way_comparison
789  template<typename _Key, typename _Tp, typename _Compare, typename _Alloc>
790  inline __detail::__synth3way_t<pair<const _Key, _Tp>>
791  operator<=>(const map<_Key, _Tp, _Compare, _Alloc>& __lhs,
793  { return __lhs._M_base() <=> __rhs._M_base(); }
794 #else
795  template<typename _Key, typename _Tp,
796  typename _Compare, typename _Allocator>
797  inline bool
798  operator!=(const map<_Key, _Tp, _Compare, _Allocator>& __lhs,
799  const map<_Key, _Tp, _Compare, _Allocator>& __rhs)
800  { return __lhs._M_base() != __rhs._M_base(); }
801 
802  template<typename _Key, typename _Tp,
803  typename _Compare, typename _Allocator>
804  inline bool
805  operator<(const map<_Key, _Tp, _Compare, _Allocator>& __lhs,
806  const map<_Key, _Tp, _Compare, _Allocator>& __rhs)
807  { return __lhs._M_base() < __rhs._M_base(); }
808 
809  template<typename _Key, typename _Tp,
810  typename _Compare, typename _Allocator>
811  inline bool
812  operator<=(const map<_Key, _Tp, _Compare, _Allocator>& __lhs,
813  const map<_Key, _Tp, _Compare, _Allocator>& __rhs)
814  { return __lhs._M_base() <= __rhs._M_base(); }
815 
816  template<typename _Key, typename _Tp,
817  typename _Compare, typename _Allocator>
818  inline bool
819  operator>=(const map<_Key, _Tp, _Compare, _Allocator>& __lhs,
820  const map<_Key, _Tp, _Compare, _Allocator>& __rhs)
821  { return __lhs._M_base() >= __rhs._M_base(); }
822 
823  template<typename _Key, typename _Tp,
824  typename _Compare, typename _Allocator>
825  inline bool
826  operator>(const map<_Key, _Tp, _Compare, _Allocator>& __lhs,
827  const map<_Key, _Tp, _Compare, _Allocator>& __rhs)
828  { return __lhs._M_base() > __rhs._M_base(); }
829 #endif // three-way comparison
830 
831  template<typename _Key, typename _Tp,
832  typename _Compare, typename _Allocator>
833  inline void
834  swap(map<_Key, _Tp, _Compare, _Allocator>& __lhs,
835  map<_Key, _Tp, _Compare, _Allocator>& __rhs)
836  _GLIBCXX_NOEXCEPT_IF(noexcept(__lhs.swap(__rhs)))
837  { __lhs.swap(__rhs); }
838 
839 } // namespace __debug
840 } // namespace std
841 
842 #endif
#define __glibcxx_check_insert(_Position)
Definition: macros.h:143
#define __glibcxx_check_erase_range(_First, _Last)
Definition: macros.h:245
#define __glibcxx_check_erase(_Position)
Definition: macros.h:209
constexpr bool operator<=(const duration< _Rep1, _Period1 > &__lhs, const duration< _Rep2, _Period2 > &__rhs)
Definition: chrono.h:859
constexpr bool operator>=(const duration< _Rep1, _Period1 > &__lhs, const duration< _Rep2, _Period2 > &__rhs)
Definition: chrono.h:873
constexpr bool operator<(const duration< _Rep1, _Period1 > &__lhs, const duration< _Rep2, _Period2 > &__rhs)
Definition: chrono.h:826
constexpr bool operator>(const duration< _Rep1, _Period1 > &__lhs, const duration< _Rep2, _Period2 > &__rhs)
Definition: chrono.h:866
constexpr std::remove_reference< _Tp >::type && move(_Tp &&__t) noexcept
Convert a value to an rvalue.
Definition: move.h:138
ISO C++ entities toplevel namespace is std.
constexpr auto empty(const _Container &__cont) noexcept(noexcept(__cont.empty())) -> decltype(__cont.empty())
Return whether a container is empty.
Definition: range_access.h:294
constexpr auto size(const _Container &__cont) noexcept(noexcept(__cont.size())) -> decltype(__cont.size())
Return the size of a container.
Definition: range_access.h:274
constexpr _Iterator __base(_Iterator __it)
initializer_list
Define a member typedef type only if a boolean constant is true.
Definition: type_traits:134
is_constructible
Definition: type_traits:1158
The standard allocator, as per C++03 [20.4.1].
Definition: allocator.h:134
Safe iterator wrapper.
constexpr _Iterator & base() noexcept
Return the underlying iterator.
Return type of insert(node_handle&&) on unique maps/sets.
Definition: node_handle.h:398
One of the comparison functors.
Definition: stl_function.h:401
Struct holding two objects of arbitrary type.
Definition: stl_pair.h:304
_T1 first
The first member.
Definition: stl_pair.h:308
_T2 second
The second member.
Definition: stl_pair.h:309
A standard container made up of (key,value) pairs, which can be retrieved based on a key,...
Definition: stl_map.h:106
void _M_invalidate_if(_Predicate __pred)
Class std::map with safety/checking/debug instrumentation.
Definition: map.h:49
Safe class dealing with some allocator dependent operations.
Like _Safe_sequence but with a special _M_invalidate_all implementation not invalidating past-the-end...