]> git.ipfire.org Git - thirdparty/gcc.git/blame - libstdc++-v3/include/debug/multiset.h
projects / thirdparty / gcc.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
testsuite: Rename a test
[thirdparty/gcc.git] / libstdc++-v3 / include / debug / multiset.h
CommitLineData
285b36d6
BK		 1// Debugging multiset implementation -*- C++ -*-
2
6441eb6d 3// Copyright (C) 2003-2025 Free Software Foundation, Inc.
285b36d6
BK		 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
748086b7 8// Free Software Foundation; either version 3, or (at your option)
285b36d6
BK		 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
748086b7
JJ		 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/>.
285b36d6 24
78a53887
BK		 25/** @file debug/multiset.h
26 * This file is a GNU debug extension to the Standard C++ Library.
27 */
28
285b36d6
BK		 29#ifndef _GLIBCXX_DEBUG_MULTISET_H
30#define _GLIBCXX_DEBUG_MULTISET_H 1
31
32#include <debug/safe_sequence.h>
15ee1a77 33#include <debug/safe_container.h>
285b36d6 34#include <debug/safe_iterator.h>
16158c96 35#include <bits/stl_pair.h>
285b36d6 36
12ffa228 37namespace std _GLIBCXX_VISIBILITY(default)
3cbc7af0 38{
45f388bb 39namespace __debug
285b36d6 40{
1ceb9e06 41 /// Class std::multiset with safety/checking/debug instrumentation.
285b36d6
BK		 42 template<typename _Key, typename _Compare = std::less<_Key>,
43 typename _Allocator = std::allocator<_Key> >
526da49c 44 class multiset
15ee1a77
FD		 45 : public __gnu_debug::_Safe_container<
46 multiset<_Key, _Compare, _Allocator>, _Allocator,
47 __gnu_debug::_Safe_node_sequence>,
48 public _GLIBCXX_STD_C::multiset<_Key, _Compare, _Allocator>
285b36d6 49 {
15ee1a77
FD		 50 typedef _GLIBCXX_STD_C::multiset<_Key, _Compare, _Allocator> _Base;
51 typedef __gnu_debug::_Safe_container<
52 multiset, _Allocator, __gnu_debug::_Safe_node_sequence> _Safe;
285b36d6 53
15ee1a77
FD		 54 typedef typename _Base::const_iterator _Base_const_iterator;
55 typedef typename _Base::iterator _Base_iterator;
afe96d41 56 typedef __gnu_debug::_Equal_to<_Base_const_iterator> _Equal;
51835a80 57
e9afbed0
FD		 58 template<typename _ItT, typename _SeqT, typename _CatT>
59 friend class ::__gnu_debug::_Safe_iterator;
60
eca833b8
JW		 61 // Reference wrapper for base class. Disambiguates multiset(const _Base&)
62 // from copy constructor by requiring a user-defined conversion.
63 // See PR libstdc++/90102.
64 struct _Base_ref
65 {
66 _Base_ref(const _Base& __r) : _M_ref(__r) { }
67
68 const _Base& _M_ref;
69 };
70
285b36d6
BK		 71 public:
72 // types:
15ee1a77
FD		 73 typedef _Key key_type;
74 typedef _Key value_type;
75 typedef _Compare key_compare;
76 typedef _Compare value_compare;
77 typedef _Allocator allocator_type;
78 typedef typename _Base::reference reference;
79 typedef typename _Base::const_reference const_reference;
285b36d6 80
afe96d41 81 typedef __gnu_debug::_Safe_iterator<_Base_iterator, multiset>
15ee1a77 82 iterator;
afe96d41 83 typedef __gnu_debug::_Safe_iterator<_Base_const_iterator,
15ee1a77 84 multiset> const_iterator;
285b36d6 85
15ee1a77
FD		 86 typedef typename _Base::size_type size_type;
87 typedef typename _Base::difference_type difference_type;
88 typedef typename _Base::pointer pointer;
89 typedef typename _Base::const_pointer const_pointer;
90 typedef std::reverse_iterator<iterator> reverse_iterator;
91 typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
285b36d6
BK		 92
93 // 23.3.3.1 construct/copy/destroy:
c3cdd71f 94
15ee1a77 95#if __cplusplus < 201103L
c3cdd71f
JW		 96 multiset() : _Base() { }
97
ed540c0a 98 multiset(const multiset& __x)
4c2d93db 99 : _Base(__x) { }
526da49c 100
15ee1a77
FD		 101 ~multiset() { }
102#else
103 multiset() = default;
104 multiset(const multiset&) = default;
105 multiset(multiset&&) = default;
988499f4
JM		 106
107 multiset(initializer_list<value_type> __l,
108 const _Compare& __comp = _Compare(),
109 const allocator_type& __a = allocator_type())
4c2d93db 110 : _Base(__l, __comp, __a) { }
51835a80
FD		 111
112 explicit
113 multiset(const allocator_type& __a)
114 : _Base(__a) { }
115
22d34a2a
JW		 116 multiset(const multiset& __m,
117 const __type_identity_t<allocator_type>& __a)
51835a80
FD		 118 : _Base(__m, __a) { }
119
22d34a2a 120 multiset(multiset&& __m, const __type_identity_t<allocator_type>& __a)
e9a53a4f
FD		 121 noexcept( noexcept(_Base(std::move(__m), __a)) )
122 : _Safe(std::move(__m), __a),
123 _Base(std::move(__m), __a) { }
51835a80
FD		 124
125 multiset(initializer_list<value_type> __l, const allocator_type& __a)
126 : _Base(__l, __a)
127 { }
128
129 template<typename _InputIterator>
15ee1a77 130 multiset(_InputIterator __first, _InputIterator __last,
51835a80 131 const allocator_type& __a)
90aabc7e
FD		 132 : _Base(__gnu_debug::__base(
133 __glibcxx_check_valid_constructor_range(__first, __last)),
15ee1a77
FD		 134 __gnu_debug::__base(__last), __a) { }
135
ae54d8cb 136#if __glibcxx_containers_ranges // C++ >= 23
f3253bd7
JW		 137 /**
138 * @brief Construct a multiset from a range.
139 * @since C++23
140 */
141 template<std::__detail::__container_compatible_range<value_type> _Rg>
142 multiset(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 multiset(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
15ee1a77 155 ~multiset() = default;
ed540c0a 156#endif
285b36d6 157
15ee1a77
FD		 158 explicit multiset(const _Compare& __comp,
159 const _Allocator& __a = _Allocator())
160 : _Base(__comp, __a) { }
161
162 template<typename _InputIterator>
163 multiset(_InputIterator __first, _InputIterator __last,
164 const _Compare& __comp = _Compare(),
165 const _Allocator& __a = _Allocator())
90aabc7e
FD		 166 : _Base(__gnu_debug::__base(
167 __glibcxx_check_valid_constructor_range(__first, __last)),
15ee1a77
FD		 168 __gnu_debug::__base(__last),
169 __comp, __a) { }
170
eca833b8
JW		 171 multiset(_Base_ref __x)
172 : _Base(__x._M_ref) { }
285b36d6 173
4a407d35 174#if __cplusplus >= 201103L
15ee1a77
FD		 175 multiset&
176 operator=(const multiset&) = default;
285b36d6 177
ed540c0a 178 multiset&
15ee1a77 179 operator=(multiset&&) = default;
988499f4
JM		 180
181 multiset&
182 operator=(initializer_list<value_type> __l)
183 {
e9a53a4f 184 _Base::operator=(__l);
51835a80 185 this->_M_invalidate_all();
988499f4
JM		 186 return *this;
187 }
ed540c0a
CJ		 188#endif
189
285b36d6
BK		 190 using _Base::get_allocator;
191
192 // iterators:
193 iterator
d3677132 194 begin() _GLIBCXX_NOEXCEPT
285b36d6
BK		 195 { return iterator(_Base::begin(), this); }
196
526da49c 197 const_iterator
d3677132 198 begin() const _GLIBCXX_NOEXCEPT
285b36d6
BK		 199 { return const_iterator(_Base::begin(), this); }
200
526da49c 201 iterator
d3677132 202 end() _GLIBCXX_NOEXCEPT
285b36d6
BK		 203 { return iterator(_Base::end(), this); }
204
526da49c 205 const_iterator
d3677132 206 end() const _GLIBCXX_NOEXCEPT
285b36d6
BK		 207 { return const_iterator(_Base::end(), this); }
208
526da49c 209 reverse_iterator
d3677132 210 rbegin() _GLIBCXX_NOEXCEPT
285b36d6
BK		 211 { return reverse_iterator(end()); }
212
526da49c 213 const_reverse_iterator
d3677132 214 rbegin() const _GLIBCXX_NOEXCEPT
285b36d6
BK		 215 { return const_reverse_iterator(end()); }
216
526da49c 217 reverse_iterator
d3677132 218 rend() _GLIBCXX_NOEXCEPT
285b36d6
BK		 219 { return reverse_iterator(begin()); }
220
526da49c 221 const_reverse_iterator
d3677132 222 rend() const _GLIBCXX_NOEXCEPT
285b36d6
BK		 223 { return const_reverse_iterator(begin()); }
224
734f5023 225#if __cplusplus >= 201103L
0cd50f89 226 const_iterator
d3677132 227 cbegin() const noexcept
0cd50f89
PC		 228 { return const_iterator(_Base::begin(), this); }
229
230 const_iterator
d3677132 231 cend() const noexcept
0cd50f89
PC		 232 { return const_iterator(_Base::end(), this); }
233
234 const_reverse_iterator
d3677132 235 crbegin() const noexcept
0cd50f89
PC		 236 { return const_reverse_iterator(end()); }
237
238 const_reverse_iterator
d3677132 239 crend() const noexcept
0cd50f89
PC		 240 { return const_reverse_iterator(begin()); }
241#endif
242
285b36d6
BK		 243 // capacity:
244 using _Base::empty;
245 using _Base::size;
246 using _Base::max_size;
247
248 // modifiers:
734f5023 249#if __cplusplus >= 201103L
55826ab6
FD		 250 template<typename... _Args>
251 iterator
252 emplace(_Args&&... __args)
784779d4 253 { return { _Base::emplace(std::forward<_Args>(__args)...), this }; }
55826ab6
FD		 254
255 template<typename... _Args>
256 iterator
257 emplace_hint(const_iterator __pos, _Args&&... __args)
258 {
259 __glibcxx_check_insert(__pos);
784779d4
FD		 260 return
261 {
262 _Base::emplace_hint(__pos.base(), std::forward<_Args>(__args)...),
263 this
264 };
55826ab6
FD		 265 }
266#endif
267
526da49c 268 iterator
285b36d6
BK		 269 insert(const value_type& __x)
270 { return iterator(_Base::insert(__x), this); }
271
734f5023 272#if __cplusplus >= 201103L
e6a05448
PC		 273 iterator
274 insert(value_type&& __x)
784779d4 275 { return { _Base::insert(std::move(__x)), this }; }
e6a05448
PC		 276#endif
277
526da49c 278 iterator
6b6d5d09 279 insert(const_iterator __position, const value_type& __x)
285b36d6
BK		 280 {
281 __glibcxx_check_insert(__position);
282 return iterator(_Base::insert(__position.base(), __x), this);
283 }
284
734f5023 285#if __cplusplus >= 201103L
e6a05448
PC		 286 iterator
287 insert(const_iterator __position, value_type&& __x)
288 {
289 __glibcxx_check_insert(__position);
784779d4 290 return { _Base::insert(__position.base(), std::move(__x)), this };
e6a05448
PC		 291 }
292#endif
293
285b36d6 294 template<typename _InputIterator>
1f5ca1a1
PC		 295 void
296 insert(_InputIterator __first, _InputIterator __last)
297 {
24167c42
FD		 298 typename __gnu_debug::_Distance_traits<_InputIterator>::__type __dist;
299 __glibcxx_check_valid_range2(__first, __last, __dist);
300
301 if (__dist.second >= __gnu_debug::__dp_sign)
302 _Base::insert(__gnu_debug::__unsafe(__first),
303 __gnu_debug::__unsafe(__last));
304 else
305 _Base::insert(__first, __last);
1f5ca1a1 306 }
285b36d6 307
734f5023 308#if __cplusplus >= 201103L
988499f4
JM		 309 void
310 insert(initializer_list<value_type> __l)
311 { _Base::insert(__l); }
312#endif
313
2dbe56bd
JW		 314#if __cplusplus > 201402L
315 using node_type = typename _Base::node_type;
316
317 node_type
318 extract(const_iterator __position)
319 {
320 __glibcxx_check_erase(__position);
321 this->_M_invalidate_if(_Equal(__position.base()));
322 return _Base::extract(__position.base());
323 }
324
325 node_type
326 extract(const key_type& __key)
327 {
328 const auto __position = find(__key);
329 if (__position != end())
330 return extract(__position);
331 return {};
332 }
333
334 iterator
335 insert(node_type&& __nh)
784779d4 336 { return { _Base::insert(std::move(__nh)), this }; }
2dbe56bd
JW		 337
338 iterator
339 insert(const_iterator __hint, node_type&& __nh)
340 {
341 __glibcxx_check_insert(__hint);
784779d4 342 return { _Base::insert(__hint.base(), std::move(__nh)), this };
2dbe56bd
JW		 343 }
344
345 using _Base::merge;
346#endif // C++17
347
734f5023 348#if __cplusplus >= 201103L
7b1e8acf 349 _GLIBCXX_ABI_TAG_CXX11
5ab06c6d 350 iterator
6b6d5d09 351 erase(const_iterator __position)
5ab06c6d
PC		 352 {
353 __glibcxx_check_erase(__position);
5f40d34b
FD		 354 return { erase(__position.base()), this };
355 }
356
357 _Base_iterator
358 erase(_Base_const_iterator __position)
359 {
360 __glibcxx_check_erase2(__position);
361 this->_M_invalidate_if(_Equal(__position));
362 return _Base::erase(__position);
5ab06c6d
PC		 363 }
364#else
526da49c 365 void
285b36d6
BK		 366 erase(iterator __position)
367 {
368 __glibcxx_check_erase(__position);
afe96d41 369 this->_M_invalidate_if(_Equal(__position.base()));
285b36d6
BK		 370 _Base::erase(__position.base());
371 }
5ab06c6d 372#endif
285b36d6
BK		 373
374 size_type
375 erase(const key_type& __x)
376 {
afe96d41
FD		 377 std::pair<_Base_iterator, _Base_iterator> __victims =
378 _Base::equal_range(__x);
285b36d6 379 size_type __count = 0;
afe96d41
FD		 380 _Base_iterator __victim = __victims.first;
381 while (__victim != __victims.second)
382 {
383 this->_M_invalidate_if(_Equal(__victim));
384 _Base::erase(__victim++);
385 ++__count;
386 }
285b36d6
BK		 387 return __count;
388 }
389
734f5023 390#if __cplusplus >= 201103L
7b1e8acf 391 _GLIBCXX_ABI_TAG_CXX11
5ab06c6d 392 iterator
6b6d5d09 393 erase(const_iterator __first, const_iterator __last)
5ab06c6d
PC		 394 {
395 // _GLIBCXX_RESOLVE_LIB_DEFECTS
396 // 151. can't currently clear() empty container
397 __glibcxx_check_erase_range(__first, __last);
afe96d41
FD		 398 for (_Base_const_iterator __victim = __first.base();
399 __victim != __last.base(); ++__victim)
400 {
e0b9bc23 401 _GLIBCXX_DEBUG_VERIFY(__victim != _Base::cend(),
afe96d41
FD		 402 _M_message(__gnu_debug::__msg_valid_range)
403 ._M_iterator(__first, "first")
404 ._M_iterator(__last, "last"));
405 this->_M_invalidate_if(_Equal(__victim));
406 }
784779d4
FD		 407
408 return { _Base::erase(__first.base(), __last.base()), this };
5ab06c6d
PC		 409 }
410#else
526da49c 411 void
285b36d6
BK		 412 erase(iterator __first, iterator __last)
413 {
414 // _GLIBCXX_RESOLVE_LIB_DEFECTS
415 // 151. can't currently clear() empty container
416 __glibcxx_check_erase_range(__first, __last);
afe96d41
FD		 417 for (_Base_iterator __victim = __first.base();
418 __victim != __last.base(); ++__victim)
419 {
420 _GLIBCXX_DEBUG_VERIFY(__victim != _Base::end(),
421 _M_message(__gnu_debug::__msg_valid_range)
422 ._M_iterator(__first, "first")
423 ._M_iterator(__last, "last"));
424 this->_M_invalidate_if(_Equal(__victim));
425 }
426 _Base::erase(__first.base(), __last.base());
285b36d6 427 }
5ab06c6d 428#endif
285b36d6 429
526da49c 430 void
ed540c0a 431 swap(multiset& __x)
c5d9ec56 432 _GLIBCXX_NOEXCEPT_IF( noexcept(declval<_Base&>().swap(__x)) )
285b36d6 433 {
15ee1a77 434 _Safe::_M_swap(__x);
285b36d6 435 _Base::swap(__x);
285b36d6
BK		 436 }
437
526da49c 438 void
d3677132 439 clear() _GLIBCXX_NOEXCEPT
afe96d41
FD		 440 {
441 this->_M_invalidate_all();
442 _Base::clear();
443 }
285b36d6
BK		 444
445 // observers:
446 using _Base::key_comp;
447 using _Base::value_comp;
448
449 // multiset operations:
526da49c 450 iterator
285b36d6
BK		 451 find(const key_type& __x)
452 { return iterator(_Base::find(__x), this); }
453
454 // _GLIBCXX_RESOLVE_LIB_DEFECTS
455 // 214. set::find() missing const overload
526da49c 456 const_iterator
285b36d6
BK		 457 find(const key_type& __x) const
458 { return const_iterator(_Base::find(__x), this); }
459
d7b35f22
FD		 460#if __cplusplus > 201103L
461 template<typename _Kt,
462 typename _Req =
463 typename __has_is_transparent<_Compare, _Kt>::type>
464 iterator
465 find(const _Kt& __x)
466 { return { _Base::find(__x), this }; }
467
468 template<typename _Kt,
469 typename _Req =
470 typename __has_is_transparent<_Compare, _Kt>::type>
471 const_iterator
472 find(const _Kt& __x) const
473 { return { _Base::find(__x), this }; }
474#endif
475
285b36d6
BK		 476 using _Base::count;
477
526da49c 478 iterator
285b36d6
BK		 479 lower_bound(const key_type& __x)
480 { return iterator(_Base::lower_bound(__x), this); }
481
482 // _GLIBCXX_RESOLVE_LIB_DEFECTS
483 // 214. set::find() missing const overload
526da49c 484 const_iterator
285b36d6
BK		 485 lower_bound(const key_type& __x) const
486 { return const_iterator(_Base::lower_bound(__x), this); }
487
d7b35f22
FD		 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 { return { _Base::lower_bound(__x), this }; }
495
496 template<typename _Kt,
497 typename _Req =
498 typename __has_is_transparent<_Compare, _Kt>::type>
499 const_iterator
500 lower_bound(const _Kt& __x) const
501 { return { _Base::lower_bound(__x), this }; }
502#endif
503
526da49c 504 iterator
285b36d6
BK		 505 upper_bound(const key_type& __x)
506 { return iterator(_Base::upper_bound(__x), this); }
507
508 // _GLIBCXX_RESOLVE_LIB_DEFECTS
509 // 214. set::find() missing const overload
526da49c 510 const_iterator
285b36d6
BK		 511 upper_bound(const key_type& __x) const
512 { return const_iterator(_Base::upper_bound(__x), this); }
513
d7b35f22
FD		 514#if __cplusplus > 201103L
515 template<typename _Kt,
516 typename _Req =
517 typename __has_is_transparent<_Compare, _Kt>::type>
518 iterator
519 upper_bound(const _Kt& __x)
520 { return { _Base::upper_bound(__x), this }; }
521
522 template<typename _Kt,
523 typename _Req =
524 typename __has_is_transparent<_Compare, _Kt>::type>
525 const_iterator
526 upper_bound(const _Kt& __x) const
527 { return { _Base::upper_bound(__x), this }; }
528#endif
529
285b36d6
BK		 530 std::pair<iterator,iterator>
531 equal_range(const key_type& __x)
532 {
285b36d6 533 std::pair<_Base_iterator, _Base_iterator> __res =
afe96d41 534 _Base::equal_range(__x);
285b36d6
BK		 535 return std::make_pair(iterator(__res.first, this),
536 iterator(__res.second, this));
537 }
538
539 // _GLIBCXX_RESOLVE_LIB_DEFECTS
540 // 214. set::find() missing const overload
541 std::pair<const_iterator,const_iterator>
542 equal_range(const key_type& __x) const
543 {
afe96d41
FD		 544 std::pair<_Base_const_iterator, _Base_const_iterator> __res =
545 _Base::equal_range(__x);
285b36d6
BK		 546 return std::make_pair(const_iterator(__res.first, this),
547 const_iterator(__res.second, this));
548 }
549
d7b35f22
FD		 550#if __cplusplus > 201103L
551 template<typename _Kt,
552 typename _Req =
553 typename __has_is_transparent<_Compare, _Kt>::type>
554 std::pair<iterator, iterator>
555 equal_range(const _Kt& __x)
556 {
557 auto __res = _Base::equal_range(__x);
558 return { { __res.first, this }, { __res.second, this } };
559 }
560
561 template<typename _Kt,
562 typename _Req =
563 typename __has_is_transparent<_Compare, _Kt>::type>
564 std::pair<const_iterator, const_iterator>
565 equal_range(const _Kt& __x) const
566 {
567 auto __res = _Base::equal_range(__x);
568 return { { __res.first, this }, { __res.second, this } };
569 }
570#endif
571
526da49c 572 _Base&
15ee1a77 573 _M_base() _GLIBCXX_NOEXCEPT { return *this; }
285b36d6 574
526da49c 575 const _Base&
d3677132 576 _M_base() const _GLIBCXX_NOEXCEPT { return *this; }
285b36d6
BK		 577 };
578
957f5fea
VV		 579#if __cpp_deduction_guides >= 201606
580
581 template<typename _InputIterator,
582 typename _Compare =
583 less<typename iterator_traits<_InputIterator>::value_type>,
584 typename _Allocator =
585 allocator<typename iterator_traits<_InputIterator>::value_type>,
586 typename = _RequireInputIter<_InputIterator>,
c0cb38c2 587 typename = _RequireNotAllocator<_Compare>,
957f5fea 588 typename = _RequireAllocator<_Allocator>>
c0cb38c2
FD		 589 multiset(_InputIterator, _InputIterator,
590 _Compare = _Compare(), _Allocator = _Allocator())
591 -> multiset<typename iterator_traits<_InputIterator>::value_type,
592 _Compare, _Allocator>;
593
594 template<typename _Key,
595 typename _Compare = less<_Key>,
596 typename _Allocator = allocator<_Key>,
597 typename = _RequireNotAllocator<_Compare>,
598 typename = _RequireAllocator<_Allocator>>
599 multiset(initializer_list<_Key>,
600 _Compare = _Compare(), _Allocator = _Allocator())
601 -> multiset<_Key, _Compare, _Allocator>;
602
603 template<typename _InputIterator, typename _Allocator,
604 typename = _RequireInputIter<_InputIterator>,
605 typename = _RequireAllocator<_Allocator>>
606 multiset(_InputIterator, _InputIterator, _Allocator)
607 -> multiset<typename iterator_traits<_InputIterator>::value_type,
608 less<typename iterator_traits<_InputIterator>::value_type>,
609 _Allocator>;
610
611 template<typename _Key, typename _Allocator,
612 typename = _RequireAllocator<_Allocator>>
613 multiset(initializer_list<_Key>, _Allocator)
614 -> multiset<_Key, less<_Key>, _Allocator>;
957f5fea 615
ae54d8cb 616#if __glibcxx_containers_ranges // C++ >= 23
f3253bd7
JW		 617 template<ranges::input_range _Rg,
618 __not_allocator_like _Compare = less<ranges::range_value_t<_Rg>>,
619 __allocator_like _Alloc = std::allocator<ranges::range_value_t<_Rg>>>
620 multiset(from_range_t, _Rg&&, _Compare = _Compare(), _Alloc = _Alloc())
621 -> multiset<ranges::range_value_t<_Rg>, _Compare, _Alloc>;
622
623 template<ranges::input_range _Rg, __allocator_like _Alloc>
624 multiset(from_range_t, _Rg&&, _Alloc)
625 -> multiset<ranges::range_value_t<_Rg>, less<ranges::range_value_t<_Rg>>, _Alloc>;
626#endif
93843da6 627#endif // deduction guides
957f5fea 628
285b36d6 629 template<typename _Key, typename _Compare, typename _Allocator>
526da49c 630 inline bool
ed540c0a
CJ		 631 operator==(const multiset<_Key, _Compare, _Allocator>& __lhs,
632 const multiset<_Key, _Compare, _Allocator>& __rhs)
285b36d6
BK		 633 { return __lhs._M_base() == __rhs._M_base(); }
634
93843da6
JW		 635#if __cpp_lib_three_way_comparison
636 template<typename _Key, typename _Compare, typename _Alloc>
637 inline __detail::__synth3way_t<_Key>
638 operator<=>(const multiset<_Key, _Compare, _Alloc>& __lhs,
639 const multiset<_Key, _Compare, _Alloc>& __rhs)
640 { return __lhs._M_base() <=> __rhs._M_base(); }
641#else
285b36d6 642 template<typename _Key, typename _Compare, typename _Allocator>
526da49c 643 inline bool
ed540c0a
CJ		 644 operator!=(const multiset<_Key, _Compare, _Allocator>& __lhs,
645 const multiset<_Key, _Compare, _Allocator>& __rhs)
285b36d6
BK		 646 { return __lhs._M_base() != __rhs._M_base(); }
647
648 template<typename _Key, typename _Compare, typename _Allocator>
526da49c 649 inline bool
ed540c0a
CJ		 650 operator<(const multiset<_Key, _Compare, _Allocator>& __lhs,
651 const multiset<_Key, _Compare, _Allocator>& __rhs)
285b36d6
BK		 652 { return __lhs._M_base() < __rhs._M_base(); }
653
654 template<typename _Key, typename _Compare, typename _Allocator>
526da49c 655 inline bool
ed540c0a
CJ		 656 operator<=(const multiset<_Key, _Compare, _Allocator>& __lhs,
657 const multiset<_Key, _Compare, _Allocator>& __rhs)
285b36d6
BK		 658 { return __lhs._M_base() <= __rhs._M_base(); }
659
660 template<typename _Key, typename _Compare, typename _Allocator>
526da49c 661 inline bool
ed540c0a
CJ		 662 operator>=(const multiset<_Key, _Compare, _Allocator>& __lhs,
663 const multiset<_Key, _Compare, _Allocator>& __rhs)
285b36d6
BK		 664 { return __lhs._M_base() >= __rhs._M_base(); }
665
666 template<typename _Key, typename _Compare, typename _Allocator>
526da49c 667 inline bool
ed540c0a
CJ		 668 operator>(const multiset<_Key, _Compare, _Allocator>& __lhs,
669 const multiset<_Key, _Compare, _Allocator>& __rhs)
285b36d6 670 { return __lhs._M_base() > __rhs._M_base(); }
93843da6 671#endif // three-way comparison
285b36d6
BK		 672
673 template<typename _Key, typename _Compare, typename _Allocator>
674 void
ed540c0a
CJ		 675 swap(multiset<_Key, _Compare, _Allocator>& __x,
676 multiset<_Key, _Compare, _Allocator>& __y)
c5d9ec56 677 _GLIBCXX_NOEXCEPT_IF(noexcept(__x.swap(__y)))
285b36d6 678 { return __x.swap(__y); }
ed540c0a 679
45f388bb 680} // namespace __debug
3cbc7af0 681} // namespace std
285b36d6
BK		 682
683#endif
Mirror of https://gcc.gnu.org/git/gcc.git