master
1// -*- C++ -*-
2//===----------------------------------------------------------------------===//
3//
4// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
5// See https://llvm.org/LICENSE.txt for license information.
6// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
7//
8//===----------------------------------------------------------------------===//
9
10#ifndef _LIBCPP_QUEUE
11#define _LIBCPP_QUEUE
12
13/*
14 queue synopsis
15
16namespace std
17{
18
19template <class T, class Container = deque<T>>
20class queue
21{
22public:
23 typedef Container container_type;
24 typedef typename container_type::value_type value_type;
25 typedef typename container_type::reference reference;
26 typedef typename container_type::const_reference const_reference;
27 typedef typename container_type::size_type size_type;
28
29protected:
30 container_type c;
31
32public:
33 queue() = default;
34 ~queue() = default;
35
36 queue(const queue& q) = default;
37 queue(queue&& q) = default;
38
39 queue& operator=(const queue& q) = default;
40 queue& operator=(queue&& q) = default;
41
42 explicit queue(const container_type& c);
43 explicit queue(container_type&& c)
44 template<class InputIterator>
45 queue(InputIterator first, InputIterator last); // since C++23
46 template<container-compatible-range<T> R> queue(from_range_t, R&& rg); // since C++23
47 template <class Alloc>
48 explicit queue(const Alloc& a);
49 template <class Alloc>
50 queue(const container_type& c, const Alloc& a);
51 template <class Alloc>
52 queue(container_type&& c, const Alloc& a);
53 template <class Alloc>
54 queue(const queue& q, const Alloc& a);
55 template <class Alloc>
56 queue(queue&& q, const Alloc& a);
57 template <class InputIterator, class Alloc>
58 queue(InputIterator first, InputIterator last, const Alloc&); // since C++23
59 template<container-compatible-range<T> R, class Alloc>
60 queue(from_range_t, R&& rg, const Alloc&); // since C++23
61
62 bool empty() const;
63 size_type size() const;
64
65 reference front();
66 const_reference front() const;
67 reference back();
68 const_reference back() const;
69
70 void push(const value_type& v);
71 void push(value_type&& v);
72 template<container-compatible-range<T> R>
73 void push_range(R&& rg); // C++23
74 template <class... Args> reference emplace(Args&&... args); // reference in C++17
75 void pop();
76
77 void swap(queue& q) noexcept(is_nothrow_swappable_v<Container>)
78};
79
80template<class Container>
81 queue(Container) -> queue<typename Container::value_type, Container>; // C++17
82
83template<class InputIterator>
84 queue(InputIterator, InputIterator) -> queue<iter-value-type<InputIterator>>; // since C++23
85
86template<ranges::input_range R>
87 queue(from_range_t, R&&) -> queue<ranges::range_value_t<R>>; // since C++23
88
89template<class Container, class Allocator>
90 queue(Container, Allocator) -> queue<typename Container::value_type, Container>; // C++17
91
92template<class InputIterator, class Allocator>
93 queue(InputIterator, InputIterator, Allocator)
94 -> queue<iter-value-type<InputIterator>,
95 deque<iter-value-type<InputIterator>, Allocator>>; // since C++23
96
97template<ranges::input_range R, class Allocator>
98 queue(from_range_t, R&&, Allocator)
99 -> queue<ranges::range_value_t<R>, deque<ranges::range_value_t<R>, Allocator>>; // since C++23
100
101template <class T, class Container>
102 bool operator==(const queue<T, Container>& x,const queue<T, Container>& y);
103
104template <class T, class Container>
105 bool operator< (const queue<T, Container>& x,const queue<T, Container>& y);
106
107template <class T, class Container>
108 bool operator!=(const queue<T, Container>& x,const queue<T, Container>& y);
109
110template <class T, class Container>
111 bool operator> (const queue<T, Container>& x,const queue<T, Container>& y);
112
113template <class T, class Container>
114 bool operator>=(const queue<T, Container>& x,const queue<T, Container>& y);
115
116template <class T, class Container>
117 bool operator<=(const queue<T, Container>& x,const queue<T, Container>& y);
118
119template<class T, three_way_comparable Container>
120 compare_three_way_result_t<Container>
121 operator<=>(const queue<T, Container>& x, const queue<T, Container>& y); // since C++20
122
123template <class T, class Container>
124 void swap(queue<T, Container>& x, queue<T, Container>& y)
125 noexcept(noexcept(x.swap(y)));
126
127template <class T, class Container = vector<T>,
128 class Compare = less<typename Container::value_type>>
129class priority_queue
130{
131public:
132 typedef Container container_type;
133 typedef typename container_type::value_type value_type;
134 typedef typename container_type::reference reference;
135 typedef typename container_type::const_reference const_reference;
136 typedef typename container_type::size_type size_type;
137
138protected:
139 container_type c;
140 Compare comp;
141
142public:
143 priority_queue() : priority_queue(Compare()) {} // C++20
144 explicit priority_queue(const Compare& x) : priority_queue(x, Container()) {}
145 priority_queue(const Compare& x, const Container&);
146 explicit priority_queue(const Compare& x = Compare(), Container&& = Container()); // before C++20
147 priority_queue(const Compare& x, Container&&); // C++20
148 template <class InputIterator>
149 priority_queue(InputIterator first, InputIterator last,
150 const Compare& comp = Compare());
151 template <class InputIterator>
152 priority_queue(InputIterator first, InputIterator last,
153 const Compare& comp, const Container& c);
154 template <class InputIterator>
155 priority_queue(InputIterator first, InputIterator last,
156 const Compare& comp, Container&& c);
157 template <container-compatible-range<T> R>
158 priority_queue(from_range_t, R&& rg, const Compare& x = Compare()); // since C++23
159 template <class Alloc>
160 explicit priority_queue(const Alloc& a);
161 template <class Alloc>
162 priority_queue(const Compare& comp, const Alloc& a);
163 template <class Alloc>
164 priority_queue(const Compare& comp, const Container& c,
165 const Alloc& a);
166 template <class Alloc>
167 priority_queue(const Compare& comp, Container&& c,
168 const Alloc& a);
169 template <class InputIterator>
170 priority_queue(InputIterator first, InputIterator last,
171 const Alloc& a);
172 template <class InputIterator>
173 priority_queue(InputIterator first, InputIterator last,
174 const Compare& comp, const Alloc& a);
175 template <class InputIterator>
176 priority_queue(InputIterator first, InputIterator last,
177 const Compare& comp, const Container& c, const Alloc& a);
178 template <class InputIterator>
179 priority_queue(InputIterator first, InputIterator last,
180 const Compare& comp, Container&& c, const Alloc& a);
181 template <container-compatible-range<T> R, class Alloc>
182 priority_queue(from_range_t, R&& rg, const Compare&, const Alloc&); // since C++23
183 template <container-compatible-range<T> R, class Alloc>
184 priority_queue(from_range_t, R&& rg, const Alloc&); // since C++23
185 template <class Alloc>
186 priority_queue(const priority_queue& q, const Alloc& a);
187 template <class Alloc>
188 priority_queue(priority_queue&& q, const Alloc& a);
189
190 bool empty() const;
191 size_type size() const;
192 const_reference top() const;
193
194 void push(const value_type& v);
195 void push(value_type&& v);
196 template<container-compatible-range<T> R>
197 void push_range(R&& rg); // C++23
198 template <class... Args> void emplace(Args&&... args);
199 void pop();
200
201 void swap(priority_queue& q)
202 noexcept(is_nothrow_swappable_v<Container> &&
203 is_nothrow_swappable_v<Comp>)
204};
205
206template <class Compare, class Container>
207priority_queue(Compare, Container)
208 -> priority_queue<typename Container::value_type, Container, Compare>; // C++17
209
210template<class InputIterator,
211 class Compare = less<iter-value-type<InputIterator>>,
212 class Container = vector<iter-value-type<InputIterator>>>
213priority_queue(InputIterator, InputIterator, Compare = Compare(), Container = Container())
214 -> priority_queue<iter-value-type<InputIterator>, Container, Compare>; // C++17
215
216template<ranges::input_range R, class Compare = less<ranges::range_value_t<R>>>
217 priority_queue(from_range_t, R&&, Compare = Compare())
218 -> priority_queue<ranges::range_value_t<R>, vector<ranges::range_value_t<R>>, Compare>; // C++23
219
220template<class Compare, class Container, class Allocator>
221priority_queue(Compare, Container, Allocator)
222 -> priority_queue<typename Container::value_type, Container, Compare>; // C++17
223
224template<class InputIterator, class Allocator>
225priority_queue(InputIterator, InputIterator, Allocator)
226 -> priority_queue<iter-value-type<InputIterator>,
227 vector<iter-value-type<InputIterator>, Allocator>,
228 less<iter-value-type<InputIterator>>>; // C++17
229
230template<class InputIterator, class Compare, class Allocator>
231priority_queue(InputIterator, InputIterator, Compare, Allocator)
232 -> priority_queue<iter-value-type<InputIterator>,
233 vector<iter-value-type<InputIterator>, Allocator>, Compare>; // C++17
234
235template<class InputIterator, class Compare, class Container, class Allocator>
236priority_queue(InputIterator, InputIterator, Compare, Container, Allocator)
237 -> priority_queue<typename Container::value_type, Container, Compare>; // C++17
238
239template<ranges::input_range R, class Compare, class Allocator>
240 priority_queue(from_range_t, R&&, Compare, Allocator)
241 -> priority_queue<ranges::range_value_t<R>, vector<ranges::range_value_t<R>, Allocator>,
242 Compare>; // C++23
243
244template<ranges::input_range R, class Allocator>
245 priority_queue(from_range_t, R&&, Allocator)
246 -> priority_queue<ranges::range_value_t<R>, vector<ranges::range_value_t<R>, Allocator>>; // C++23
247
248template <class T, class Container, class Compare>
249 void swap(priority_queue<T, Container, Compare>& x,
250 priority_queue<T, Container, Compare>& y)
251 noexcept(noexcept(x.swap(y)));
252
253} // std
254
255*/
256
257#if __cplusplus < 201103L && defined(_LIBCPP_USE_FROZEN_CXX03_HEADERS)
258# include <__cxx03/queue>
259#else
260# include <__algorithm/make_heap.h>
261# include <__algorithm/pop_heap.h>
262# include <__algorithm/push_heap.h>
263# include <__algorithm/ranges_copy.h>
264# include <__config>
265# include <__functional/operations.h>
266# include <__fwd/deque.h>
267# include <__fwd/queue.h>
268# include <__iterator/back_insert_iterator.h>
269# include <__iterator/iterator_traits.h>
270# include <__memory/uses_allocator.h>
271# include <__ranges/access.h>
272# include <__ranges/concepts.h>
273# include <__ranges/container_compatible_range.h>
274# include <__ranges/from_range.h>
275# include <__utility/forward.h>
276# include <deque>
277# include <vector>
278# include <version>
279
280// standard-mandated includes
281
282// [queue.syn]
283# include <compare>
284# include <initializer_list>
285
286# if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
287# pragma GCC system_header
288# endif
289
290_LIBCPP_PUSH_MACROS
291# include <__undef_macros>
292
293_LIBCPP_BEGIN_NAMESPACE_STD
294
295template <class _Tp, class _Container>
296_LIBCPP_HIDE_FROM_ABI bool operator==(const queue<_Tp, _Container>& __x, const queue<_Tp, _Container>& __y);
297
298template <class _Tp, class _Container>
299_LIBCPP_HIDE_FROM_ABI bool operator<(const queue<_Tp, _Container>& __x, const queue<_Tp, _Container>& __y);
300
301template <class _Tp, class _Container /*= deque<_Tp>*/>
302class queue {
303public:
304 typedef _Container container_type;
305 typedef typename container_type::value_type value_type;
306 typedef typename container_type::reference reference;
307 typedef typename container_type::const_reference const_reference;
308 typedef typename container_type::size_type size_type;
309 static_assert(is_same<_Tp, value_type>::value, "");
310
311protected:
312 container_type c;
313
314public:
315 _LIBCPP_HIDE_FROM_ABI queue() _NOEXCEPT_(is_nothrow_default_constructible<container_type>::value) : c() {}
316
317 _LIBCPP_HIDE_FROM_ABI queue(const queue& __q) : c(__q.c) {}
318
319# if _LIBCPP_STD_VER >= 23
320 template <class _InputIterator, __enable_if_t<__has_input_iterator_category<_InputIterator>::value, int> = 0>
321 _LIBCPP_HIDE_FROM_ABI queue(_InputIterator __first, _InputIterator __last) : c(__first, __last) {}
322
323 template <_ContainerCompatibleRange<_Tp> _Range>
324 _LIBCPP_HIDE_FROM_ABI queue(from_range_t, _Range&& __range) : c(from_range, std::forward<_Range>(__range)) {}
325
326 template <class _InputIterator,
327 class _Alloc,
328 __enable_if_t<__has_input_iterator_category<_InputIterator>::value, int> = 0,
329 __enable_if_t<uses_allocator<container_type, _Alloc>::value, int> = 0>
330 _LIBCPP_HIDE_FROM_ABI queue(_InputIterator __first, _InputIterator __second, const _Alloc& __alloc)
331 : c(__first, __second, __alloc) {}
332
333 template <_ContainerCompatibleRange<_Tp> _Range,
334 class _Alloc,
335 __enable_if_t<uses_allocator<container_type, _Alloc>::value, int> = 0>
336 _LIBCPP_HIDE_FROM_ABI queue(from_range_t, _Range&& __range, const _Alloc& __alloc)
337 : c(from_range, std::forward<_Range>(__range), __alloc) {}
338
339# endif
340
341 _LIBCPP_HIDE_FROM_ABI queue& operator=(const queue& __q) {
342 c = __q.c;
343 return *this;
344 }
345
346# ifndef _LIBCPP_CXX03_LANG
347 _LIBCPP_HIDE_FROM_ABI queue(queue&& __q) noexcept(is_nothrow_move_constructible<container_type>::value)
348 : c(std::move(__q.c)) {}
349
350 _LIBCPP_HIDE_FROM_ABI queue& operator=(queue&& __q) noexcept(is_nothrow_move_assignable<container_type>::value) {
351 c = std::move(__q.c);
352 return *this;
353 }
354# endif // _LIBCPP_CXX03_LANG
355
356 _LIBCPP_HIDE_FROM_ABI explicit queue(const container_type& __c) : c(__c) {}
357# ifndef _LIBCPP_CXX03_LANG
358 _LIBCPP_HIDE_FROM_ABI explicit queue(container_type&& __c) : c(std::move(__c)) {}
359# endif // _LIBCPP_CXX03_LANG
360
361 template <class _Alloc, __enable_if_t<uses_allocator<container_type, _Alloc>::value, int> = 0>
362 _LIBCPP_HIDE_FROM_ABI explicit queue(const _Alloc& __a) : c(__a) {}
363
364 template <class _Alloc, __enable_if_t<uses_allocator<container_type, _Alloc>::value, int> = 0>
365 _LIBCPP_HIDE_FROM_ABI queue(const queue& __q, const _Alloc& __a) : c(__q.c, __a) {}
366
367 template <class _Alloc, __enable_if_t<uses_allocator<container_type, _Alloc>::value, int> = 0>
368 _LIBCPP_HIDE_FROM_ABI queue(const container_type& __c, const _Alloc& __a) : c(__c, __a) {}
369
370# ifndef _LIBCPP_CXX03_LANG
371 template <class _Alloc, __enable_if_t<uses_allocator<container_type, _Alloc>::value, int> = 0>
372 _LIBCPP_HIDE_FROM_ABI queue(container_type&& __c, const _Alloc& __a) : c(std::move(__c), __a) {}
373
374 template <class _Alloc, __enable_if_t<uses_allocator<container_type, _Alloc>::value, int> = 0>
375 _LIBCPP_HIDE_FROM_ABI queue(queue&& __q, const _Alloc& __a) : c(std::move(__q.c), __a) {}
376# endif // _LIBCPP_CXX03_LANG
377
378 [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI bool empty() const { return c.empty(); }
379 _LIBCPP_HIDE_FROM_ABI size_type size() const { return c.size(); }
380
381 _LIBCPP_HIDE_FROM_ABI reference front() { return c.front(); }
382 _LIBCPP_HIDE_FROM_ABI const_reference front() const { return c.front(); }
383 _LIBCPP_HIDE_FROM_ABI reference back() { return c.back(); }
384 _LIBCPP_HIDE_FROM_ABI const_reference back() const { return c.back(); }
385
386 _LIBCPP_HIDE_FROM_ABI void push(const value_type& __v) { c.push_back(__v); }
387# ifndef _LIBCPP_CXX03_LANG
388 _LIBCPP_HIDE_FROM_ABI void push(value_type&& __v) { c.push_back(std::move(__v)); }
389
390# if _LIBCPP_STD_VER >= 23
391 template <_ContainerCompatibleRange<_Tp> _Range>
392 _LIBCPP_HIDE_FROM_ABI void push_range(_Range&& __range) {
393 if constexpr (requires(container_type& __c) { __c.append_range(std::forward<_Range>(__range)); }) {
394 c.append_range(std::forward<_Range>(__range));
395 } else {
396 ranges::copy(std::forward<_Range>(__range), std::back_inserter(c));
397 }
398 }
399# endif
400
401 template <class... _Args>
402 _LIBCPP_HIDE_FROM_ABI
403# if _LIBCPP_STD_VER >= 17
404 decltype(auto)
405 emplace(_Args&&... __args) {
406 return c.emplace_back(std::forward<_Args>(__args)...);
407 }
408# else
409 void
410 emplace(_Args&&... __args) {
411 c.emplace_back(std::forward<_Args>(__args)...);
412 }
413# endif
414# endif // _LIBCPP_CXX03_LANG
415 _LIBCPP_HIDE_FROM_ABI void pop() { c.pop_front(); }
416
417 _LIBCPP_HIDE_FROM_ABI void swap(queue& __q) _NOEXCEPT_(__is_nothrow_swappable_v<container_type>) {
418 using std::swap;
419 swap(c, __q.c);
420 }
421
422 [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI const _Container& __get_container() const { return c; }
423
424 template <class _T1, class _OtherContainer>
425 friend _LIBCPP_HIDE_FROM_ABI bool
426 operator==(const queue<_T1, _OtherContainer>& __x, const queue<_T1, _OtherContainer>& __y);
427
428 template <class _T1, class _OtherContainer>
429 friend _LIBCPP_HIDE_FROM_ABI bool
430 operator<(const queue<_T1, _OtherContainer>& __x, const queue<_T1, _OtherContainer>& __y);
431
432# if _LIBCPP_STD_VER >= 20
433 template <class _T1, three_way_comparable _OtherContainer>
434 friend _LIBCPP_HIDE_FROM_ABI compare_three_way_result_t<_OtherContainer>
435 operator<=>(const queue<_T1, _OtherContainer>& __x, const queue<_T1, _OtherContainer>& __y);
436# endif
437};
438
439# if _LIBCPP_STD_VER >= 17
440template <class _Container, class = enable_if_t<!__is_allocator<_Container>::value> >
441queue(_Container) -> queue<typename _Container::value_type, _Container>;
442
443template <class _Container,
444 class _Alloc,
445 class = enable_if_t<!__is_allocator<_Container>::value>,
446 class = enable_if_t<uses_allocator<_Container, _Alloc>::value> >
447queue(_Container, _Alloc) -> queue<typename _Container::value_type, _Container>;
448# endif
449
450# if _LIBCPP_STD_VER >= 23
451template <class _InputIterator, __enable_if_t<__has_input_iterator_category<_InputIterator>::value, int> = 0>
452queue(_InputIterator, _InputIterator) -> queue<__iter_value_type<_InputIterator>>;
453
454template <ranges::input_range _Range>
455queue(from_range_t, _Range&&) -> queue<ranges::range_value_t<_Range>>;
456
457template <class _InputIterator,
458 class _Alloc,
459 __enable_if_t<__has_input_iterator_category<_InputIterator>::value, int> = 0,
460 __enable_if_t<__is_allocator<_Alloc>::value, int> = 0>
461queue(_InputIterator, _InputIterator, _Alloc)
462 -> queue<__iter_value_type<_InputIterator>, deque<__iter_value_type<_InputIterator>, _Alloc>>;
463
464template <ranges::input_range _Range, class _Alloc, __enable_if_t<__is_allocator<_Alloc>::value, int> = 0>
465queue(from_range_t, _Range&&, _Alloc)
466 -> queue<ranges::range_value_t<_Range>, deque<ranges::range_value_t<_Range>, _Alloc>>;
467# endif
468
469template <class _Tp, class _Container>
470inline _LIBCPP_HIDE_FROM_ABI bool operator==(const queue<_Tp, _Container>& __x, const queue<_Tp, _Container>& __y) {
471 return __x.c == __y.c;
472}
473
474template <class _Tp, class _Container>
475inline _LIBCPP_HIDE_FROM_ABI bool operator<(const queue<_Tp, _Container>& __x, const queue<_Tp, _Container>& __y) {
476 return __x.c < __y.c;
477}
478
479template <class _Tp, class _Container>
480inline _LIBCPP_HIDE_FROM_ABI bool operator!=(const queue<_Tp, _Container>& __x, const queue<_Tp, _Container>& __y) {
481 return !(__x == __y);
482}
483
484template <class _Tp, class _Container>
485inline _LIBCPP_HIDE_FROM_ABI bool operator>(const queue<_Tp, _Container>& __x, const queue<_Tp, _Container>& __y) {
486 return __y < __x;
487}
488
489template <class _Tp, class _Container>
490inline _LIBCPP_HIDE_FROM_ABI bool operator>=(const queue<_Tp, _Container>& __x, const queue<_Tp, _Container>& __y) {
491 return !(__x < __y);
492}
493
494template <class _Tp, class _Container>
495inline _LIBCPP_HIDE_FROM_ABI bool operator<=(const queue<_Tp, _Container>& __x, const queue<_Tp, _Container>& __y) {
496 return !(__y < __x);
497}
498
499# if _LIBCPP_STD_VER >= 20
500
501template <class _Tp, three_way_comparable _Container>
502_LIBCPP_HIDE_FROM_ABI compare_three_way_result_t<_Container>
503operator<=>(const queue<_Tp, _Container>& __x, const queue<_Tp, _Container>& __y) {
504 return __x.c <=> __y.c;
505}
506
507# endif
508
509template <class _Tp, class _Container, __enable_if_t<__is_swappable_v<_Container>, int> = 0>
510inline _LIBCPP_HIDE_FROM_ABI void swap(queue<_Tp, _Container>& __x, queue<_Tp, _Container>& __y)
511 _NOEXCEPT_(_NOEXCEPT_(__x.swap(__y))) {
512 __x.swap(__y);
513}
514
515template <class _Tp, class _Container, class _Alloc>
516struct uses_allocator<queue<_Tp, _Container>, _Alloc> : public uses_allocator<_Container, _Alloc> {};
517
518template <class _Tp, class _Container, class _Compare>
519class priority_queue {
520public:
521 typedef _Container container_type;
522 typedef _Compare value_compare;
523 typedef typename container_type::value_type value_type;
524 typedef typename container_type::reference reference;
525 typedef typename container_type::const_reference const_reference;
526 typedef typename container_type::size_type size_type;
527 static_assert(is_same<_Tp, value_type>::value, "");
528
529protected:
530 container_type c;
531 value_compare comp;
532
533public:
534 _LIBCPP_CONSTEXPR_SINCE_CXX26 _LIBCPP_HIDE_FROM_ABI priority_queue() _NOEXCEPT_(
535 is_nothrow_default_constructible<container_type>::value&& is_nothrow_default_constructible<value_compare>::value)
536 : c(), comp() {}
537
538 _LIBCPP_CONSTEXPR_SINCE_CXX26 _LIBCPP_HIDE_FROM_ABI priority_queue(const priority_queue& __q)
539 : c(__q.c), comp(__q.comp) {}
540
541 _LIBCPP_CONSTEXPR_SINCE_CXX26 _LIBCPP_HIDE_FROM_ABI priority_queue& operator=(const priority_queue& __q) {
542 c = __q.c;
543 comp = __q.comp;
544 return *this;
545 }
546
547# ifndef _LIBCPP_CXX03_LANG
548 _LIBCPP_CONSTEXPR_SINCE_CXX26 _LIBCPP_HIDE_FROM_ABI priority_queue(priority_queue&& __q) noexcept(
549 is_nothrow_move_constructible<container_type>::value && is_nothrow_move_constructible<value_compare>::value)
550 : c(std::move(__q.c)), comp(std::move(__q.comp)) {}
551
552 _LIBCPP_CONSTEXPR_SINCE_CXX26 _LIBCPP_HIDE_FROM_ABI priority_queue& operator=(priority_queue&& __q) noexcept(
553 is_nothrow_move_assignable<container_type>::value && is_nothrow_move_assignable<value_compare>::value) {
554 c = std::move(__q.c);
555 comp = std::move(__q.comp);
556 return *this;
557 }
558# endif // _LIBCPP_CXX03_LANG
559
560 _LIBCPP_CONSTEXPR_SINCE_CXX26 _LIBCPP_HIDE_FROM_ABI explicit priority_queue(const value_compare& __comp)
561 : c(), comp(__comp) {}
562 _LIBCPP_CONSTEXPR_SINCE_CXX26 _LIBCPP_HIDE_FROM_ABI
563 priority_queue(const value_compare& __comp, const container_type& __c);
564# ifndef _LIBCPP_CXX03_LANG
565 _LIBCPP_CONSTEXPR_SINCE_CXX26 _LIBCPP_HIDE_FROM_ABI priority_queue(const value_compare& __comp, container_type&& __c);
566# endif
567 template <class _InputIter, __enable_if_t<__has_input_iterator_category<_InputIter>::value, int> = 0>
568 _LIBCPP_CONSTEXPR_SINCE_CXX26 _LIBCPP_HIDE_FROM_ABI
569 priority_queue(_InputIter __f, _InputIter __l, const value_compare& __comp = value_compare());
570
571 template <class _InputIter, __enable_if_t<__has_input_iterator_category<_InputIter>::value, int> = 0>
572 _LIBCPP_CONSTEXPR_SINCE_CXX26 _LIBCPP_HIDE_FROM_ABI
573 priority_queue(_InputIter __f, _InputIter __l, const value_compare& __comp, const container_type& __c);
574
575# ifndef _LIBCPP_CXX03_LANG
576 template <class _InputIter, __enable_if_t<__has_input_iterator_category<_InputIter>::value, int> = 0>
577 _LIBCPP_CONSTEXPR_SINCE_CXX26 _LIBCPP_HIDE_FROM_ABI
578 priority_queue(_InputIter __f, _InputIter __l, const value_compare& __comp, container_type&& __c);
579# endif // _LIBCPP_CXX03_LANG
580
581# if _LIBCPP_STD_VER >= 23
582 template <_ContainerCompatibleRange<_Tp> _Range>
583 _LIBCPP_CONSTEXPR_SINCE_CXX26 _LIBCPP_HIDE_FROM_ABI
584 priority_queue(from_range_t, _Range&& __range, const value_compare& __comp = value_compare())
585 : c(from_range, std::forward<_Range>(__range)), comp(__comp) {
586 std::make_heap(c.begin(), c.end(), comp);
587 }
588# endif
589
590 template <class _Alloc, __enable_if_t<uses_allocator<container_type, _Alloc>::value, int> = 0>
591 _LIBCPP_CONSTEXPR_SINCE_CXX26 _LIBCPP_HIDE_FROM_ABI explicit priority_queue(const _Alloc& __a);
592
593 template <class _Alloc, __enable_if_t<uses_allocator<container_type, _Alloc>::value, int> = 0>
594 _LIBCPP_CONSTEXPR_SINCE_CXX26 _LIBCPP_HIDE_FROM_ABI priority_queue(const value_compare& __comp, const _Alloc& __a);
595
596 template <class _Alloc, __enable_if_t<uses_allocator<container_type, _Alloc>::value, int> = 0>
597 _LIBCPP_CONSTEXPR_SINCE_CXX26 _LIBCPP_HIDE_FROM_ABI
598 priority_queue(const value_compare& __comp, const container_type& __c, const _Alloc& __a);
599
600 template <class _Alloc, __enable_if_t<uses_allocator<container_type, _Alloc>::value, int> = 0>
601 _LIBCPP_CONSTEXPR_SINCE_CXX26 _LIBCPP_HIDE_FROM_ABI priority_queue(const priority_queue& __q, const _Alloc& __a);
602
603# ifndef _LIBCPP_CXX03_LANG
604 template <class _Alloc, __enable_if_t<uses_allocator<container_type, _Alloc>::value, int> = 0>
605 _LIBCPP_CONSTEXPR_SINCE_CXX26 _LIBCPP_HIDE_FROM_ABI
606 priority_queue(const value_compare& __comp, container_type&& __c, const _Alloc& __a);
607
608 template <class _Alloc, __enable_if_t<uses_allocator<container_type, _Alloc>::value, int> = 0>
609 _LIBCPP_CONSTEXPR_SINCE_CXX26 _LIBCPP_HIDE_FROM_ABI priority_queue(priority_queue&& __q, const _Alloc& __a);
610# endif // _LIBCPP_CXX03_LANG
611
612 template <
613 class _InputIter,
614 class _Alloc,
615 __enable_if_t<__has_input_iterator_category<_InputIter>::value && uses_allocator<container_type, _Alloc>::value,
616 int> = 0>
617 _LIBCPP_CONSTEXPR_SINCE_CXX26 _LIBCPP_HIDE_FROM_ABI priority_queue(_InputIter __f, _InputIter __l, const _Alloc& __a);
618
619 template <
620 class _InputIter,
621 class _Alloc,
622 __enable_if_t<__has_input_iterator_category<_InputIter>::value && uses_allocator<container_type, _Alloc>::value,
623 int> = 0>
624 _LIBCPP_CONSTEXPR_SINCE_CXX26 _LIBCPP_HIDE_FROM_ABI
625 priority_queue(_InputIter __f, _InputIter __l, const value_compare& __comp, const _Alloc& __a);
626
627 template <
628 class _InputIter,
629 class _Alloc,
630 __enable_if_t<__has_input_iterator_category<_InputIter>::value && uses_allocator<container_type, _Alloc>::value,
631 int> = 0>
632 _LIBCPP_CONSTEXPR_SINCE_CXX26 _LIBCPP_HIDE_FROM_ABI priority_queue(
633 _InputIter __f, _InputIter __l, const value_compare& __comp, const container_type& __c, const _Alloc& __a);
634
635# ifndef _LIBCPP_CXX03_LANG
636 template <
637 class _InputIter,
638 class _Alloc,
639 __enable_if_t<__has_input_iterator_category<_InputIter>::value && uses_allocator<container_type, _Alloc>::value,
640 int> = 0>
641 _LIBCPP_CONSTEXPR_SINCE_CXX26 _LIBCPP_HIDE_FROM_ABI
642 priority_queue(_InputIter __f, _InputIter __l, const value_compare& __comp, container_type&& __c, const _Alloc& __a);
643# endif // _LIBCPP_CXX03_LANG
644
645# if _LIBCPP_STD_VER >= 23
646
647 template <_ContainerCompatibleRange<_Tp> _Range,
648 class _Alloc,
649 class = enable_if_t<uses_allocator<_Container, _Alloc>::value>>
650 _LIBCPP_CONSTEXPR_SINCE_CXX26 _LIBCPP_HIDE_FROM_ABI
651 priority_queue(from_range_t, _Range&& __range, const value_compare& __comp, const _Alloc& __a)
652 : c(from_range, std::forward<_Range>(__range), __a), comp(__comp) {
653 std::make_heap(c.begin(), c.end(), comp);
654 }
655
656 template <_ContainerCompatibleRange<_Tp> _Range,
657 class _Alloc,
658 class = enable_if_t<uses_allocator<_Container, _Alloc>::value>>
659 _LIBCPP_CONSTEXPR_SINCE_CXX26 _LIBCPP_HIDE_FROM_ABI priority_queue(from_range_t, _Range&& __range, const _Alloc& __a)
660 : c(from_range, std::forward<_Range>(__range), __a), comp() {
661 std::make_heap(c.begin(), c.end(), comp);
662 }
663
664# endif
665
666 [[__nodiscard__]] _LIBCPP_CONSTEXPR_SINCE_CXX26 _LIBCPP_HIDE_FROM_ABI bool empty() const { return c.empty(); }
667 _LIBCPP_CONSTEXPR_SINCE_CXX26 _LIBCPP_HIDE_FROM_ABI size_type size() const { return c.size(); }
668 _LIBCPP_CONSTEXPR_SINCE_CXX26 _LIBCPP_HIDE_FROM_ABI const_reference top() const { return c.front(); }
669
670 _LIBCPP_CONSTEXPR_SINCE_CXX26 _LIBCPP_HIDE_FROM_ABI void push(const value_type& __v);
671# ifndef _LIBCPP_CXX03_LANG
672 _LIBCPP_CONSTEXPR_SINCE_CXX26 _LIBCPP_HIDE_FROM_ABI void push(value_type&& __v);
673
674# if _LIBCPP_STD_VER >= 23
675 template <_ContainerCompatibleRange<_Tp> _Range>
676 _LIBCPP_CONSTEXPR_SINCE_CXX26 _LIBCPP_HIDE_FROM_ABI void push_range(_Range&& __range) {
677 if constexpr (requires(container_type& __c) { __c.append_range(std::forward<_Range>(__range)); }) {
678 c.append_range(std::forward<_Range>(__range));
679 } else {
680 ranges::copy(std::forward<_Range>(__range), std::back_inserter(c));
681 }
682
683 std::make_heap(c.begin(), c.end(), comp);
684 }
685# endif
686
687 template <class... _Args>
688 _LIBCPP_CONSTEXPR_SINCE_CXX26 _LIBCPP_HIDE_FROM_ABI void emplace(_Args&&... __args);
689# endif // _LIBCPP_CXX03_LANG
690 _LIBCPP_CONSTEXPR_SINCE_CXX26 _LIBCPP_HIDE_FROM_ABI void pop();
691
692 _LIBCPP_CONSTEXPR_SINCE_CXX26 _LIBCPP_HIDE_FROM_ABI void swap(priority_queue& __q)
693 _NOEXCEPT_(__is_nothrow_swappable_v<container_type>&& __is_nothrow_swappable_v<value_compare>);
694
695 [[__nodiscard__]] _LIBCPP_CONSTEXPR_SINCE_CXX26 _LIBCPP_HIDE_FROM_ABI const _Container& __get_container() const {
696 return c;
697 }
698};
699
700# if _LIBCPP_STD_VER >= 17
701template <class _Compare,
702 class _Container,
703 class = enable_if_t<!__is_allocator<_Compare>::value>,
704 class = enable_if_t<!__is_allocator<_Container>::value> >
705priority_queue(_Compare, _Container) -> priority_queue<typename _Container::value_type, _Container, _Compare>;
706
707template <class _InputIterator,
708 class _Compare = less<__iter_value_type<_InputIterator>>,
709 class _Container = vector<__iter_value_type<_InputIterator>>,
710 class = enable_if_t<__has_input_iterator_category<_InputIterator>::value>,
711 class = enable_if_t<!__is_allocator<_Compare>::value>,
712 class = enable_if_t<!__is_allocator<_Container>::value> >
713priority_queue(_InputIterator, _InputIterator, _Compare = _Compare(), _Container = _Container())
714 -> priority_queue<__iter_value_type<_InputIterator>, _Container, _Compare>;
715
716template <class _Compare,
717 class _Container,
718 class _Alloc,
719 class = enable_if_t<!__is_allocator<_Compare>::value>,
720 class = enable_if_t<!__is_allocator<_Container>::value>,
721 class = enable_if_t<uses_allocator<_Container, _Alloc>::value> >
722priority_queue(_Compare, _Container, _Alloc) -> priority_queue<typename _Container::value_type, _Container, _Compare>;
723
724template <class _InputIterator,
725 class _Allocator,
726 class = enable_if_t<__has_input_iterator_category<_InputIterator>::value>,
727 class = enable_if_t<__is_allocator<_Allocator>::value> >
728priority_queue(_InputIterator, _InputIterator, _Allocator)
729 -> priority_queue<__iter_value_type<_InputIterator>,
730 vector<__iter_value_type<_InputIterator>, _Allocator>,
731 less<__iter_value_type<_InputIterator>>>;
732
733template <class _InputIterator,
734 class _Compare,
735 class _Allocator,
736 class = enable_if_t<__has_input_iterator_category<_InputIterator>::value>,
737 class = enable_if_t<!__is_allocator<_Compare>::value>,
738 class = enable_if_t<__is_allocator<_Allocator>::value> >
739priority_queue(_InputIterator, _InputIterator, _Compare, _Allocator)
740 -> priority_queue<__iter_value_type<_InputIterator>,
741 vector<__iter_value_type<_InputIterator>, _Allocator>,
742 _Compare>;
743
744template <class _InputIterator,
745 class _Compare,
746 class _Container,
747 class _Alloc,
748 class = enable_if_t<__has_input_iterator_category<_InputIterator>::value>,
749 class = enable_if_t<!__is_allocator<_Compare>::value>,
750 class = enable_if_t<!__is_allocator<_Container>::value>,
751 class = enable_if_t<uses_allocator<_Container, _Alloc>::value> >
752priority_queue(_InputIterator, _InputIterator, _Compare, _Container, _Alloc)
753 -> priority_queue<typename _Container::value_type, _Container, _Compare>;
754# endif
755
756# if _LIBCPP_STD_VER >= 23
757
758template <ranges::input_range _Range,
759 class _Compare = less<ranges::range_value_t<_Range>>,
760 class = enable_if_t<!__is_allocator<_Compare>::value>>
761priority_queue(from_range_t, _Range&&, _Compare = _Compare())
762 -> priority_queue<ranges::range_value_t<_Range>, vector<ranges::range_value_t<_Range>>, _Compare>;
763
764template <ranges::input_range _Range,
765 class _Compare,
766 class _Alloc,
767 class = enable_if_t<!__is_allocator<_Compare>::value>,
768 class = enable_if_t<__is_allocator<_Alloc>::value>>
769priority_queue(from_range_t, _Range&&, _Compare, _Alloc)
770 -> priority_queue<ranges::range_value_t<_Range>, vector<ranges::range_value_t<_Range>, _Alloc>, _Compare>;
771
772template <ranges::input_range _Range, class _Alloc, class = enable_if_t<__is_allocator<_Alloc>::value>>
773priority_queue(from_range_t, _Range&&, _Alloc)
774 -> priority_queue<ranges::range_value_t<_Range>, vector<ranges::range_value_t<_Range>, _Alloc>>;
775
776# endif
777
778template <class _Tp, class _Container, class _Compare>
779_LIBCPP_CONSTEXPR_SINCE_CXX26 inline priority_queue<_Tp, _Container, _Compare>::priority_queue(
780 const _Compare& __comp, const container_type& __c)
781 : c(__c), comp(__comp) {
782 std::make_heap(c.begin(), c.end(), comp);
783}
784
785# ifndef _LIBCPP_CXX03_LANG
786
787template <class _Tp, class _Container, class _Compare>
788_LIBCPP_CONSTEXPR_SINCE_CXX26 inline priority_queue<_Tp, _Container, _Compare>::priority_queue(
789 const value_compare& __comp, container_type&& __c)
790 : c(std::move(__c)), comp(__comp) {
791 std::make_heap(c.begin(), c.end(), comp);
792}
793
794# endif // _LIBCPP_CXX03_LANG
795
796template <class _Tp, class _Container, class _Compare>
797template <class _InputIter, __enable_if_t<__has_input_iterator_category<_InputIter>::value, int> >
798_LIBCPP_CONSTEXPR_SINCE_CXX26 inline priority_queue<_Tp, _Container, _Compare>::priority_queue(
799 _InputIter __f, _InputIter __l, const value_compare& __comp)
800 : c(__f, __l), comp(__comp) {
801 std::make_heap(c.begin(), c.end(), comp);
802}
803
804template <class _Tp, class _Container, class _Compare>
805template <class _InputIter, __enable_if_t<__has_input_iterator_category<_InputIter>::value, int> >
806_LIBCPP_CONSTEXPR_SINCE_CXX26 inline priority_queue<_Tp, _Container, _Compare>::priority_queue(
807 _InputIter __f, _InputIter __l, const value_compare& __comp, const container_type& __c)
808 : c(__c), comp(__comp) {
809 c.insert(c.end(), __f, __l);
810 std::make_heap(c.begin(), c.end(), comp);
811}
812
813# ifndef _LIBCPP_CXX03_LANG
814
815template <class _Tp, class _Container, class _Compare>
816template <class _InputIter, __enable_if_t<__has_input_iterator_category<_InputIter>::value, int> >
817_LIBCPP_CONSTEXPR_SINCE_CXX26 inline priority_queue<_Tp, _Container, _Compare>::priority_queue(
818 _InputIter __f, _InputIter __l, const value_compare& __comp, container_type&& __c)
819 : c(std::move(__c)), comp(__comp) {
820 c.insert(c.end(), __f, __l);
821 std::make_heap(c.begin(), c.end(), comp);
822}
823
824# endif // _LIBCPP_CXX03_LANG
825
826template <class _Tp, class _Container, class _Compare>
827template <class _Alloc, __enable_if_t<uses_allocator<_Container, _Alloc>::value, int> >
828_LIBCPP_CONSTEXPR_SINCE_CXX26 inline priority_queue<_Tp, _Container, _Compare>::priority_queue(const _Alloc& __a)
829 : c(__a) {}
830
831template <class _Tp, class _Container, class _Compare>
832template <class _Alloc, __enable_if_t<uses_allocator<_Container, _Alloc>::value, int> >
833_LIBCPP_CONSTEXPR_SINCE_CXX26 inline priority_queue<_Tp, _Container, _Compare>::priority_queue(
834 const value_compare& __comp, const _Alloc& __a)
835 : c(__a), comp(__comp) {}
836
837template <class _Tp, class _Container, class _Compare>
838template <class _Alloc, __enable_if_t<uses_allocator<_Container, _Alloc>::value, int> >
839_LIBCPP_CONSTEXPR_SINCE_CXX26 inline priority_queue<_Tp, _Container, _Compare>::priority_queue(
840 const value_compare& __comp, const container_type& __c, const _Alloc& __a)
841 : c(__c, __a), comp(__comp) {
842 std::make_heap(c.begin(), c.end(), comp);
843}
844
845template <class _Tp, class _Container, class _Compare>
846template <class _Alloc, __enable_if_t<uses_allocator<_Container, _Alloc>::value, int> >
847_LIBCPP_CONSTEXPR_SINCE_CXX26 inline priority_queue<_Tp, _Container, _Compare>::priority_queue(
848 const priority_queue& __q, const _Alloc& __a)
849 : c(__q.c, __a), comp(__q.comp) {}
850
851# ifndef _LIBCPP_CXX03_LANG
852
853template <class _Tp, class _Container, class _Compare>
854template <class _Alloc, __enable_if_t<uses_allocator<_Container, _Alloc>::value, int> >
855_LIBCPP_CONSTEXPR_SINCE_CXX26 inline priority_queue<_Tp, _Container, _Compare>::priority_queue(
856 const value_compare& __comp, container_type&& __c, const _Alloc& __a)
857 : c(std::move(__c), __a), comp(__comp) {
858 std::make_heap(c.begin(), c.end(), comp);
859}
860
861template <class _Tp, class _Container, class _Compare>
862template <class _Alloc, __enable_if_t<uses_allocator<_Container, _Alloc>::value, int> >
863_LIBCPP_CONSTEXPR_SINCE_CXX26 inline priority_queue<_Tp, _Container, _Compare>::priority_queue(
864 priority_queue&& __q, const _Alloc& __a)
865 : c(std::move(__q.c), __a), comp(std::move(__q.comp)) {}
866
867# endif // _LIBCPP_CXX03_LANG
868
869template <class _Tp, class _Container, class _Compare>
870template <
871 class _InputIter,
872 class _Alloc,
873 __enable_if_t<__has_input_iterator_category<_InputIter>::value && uses_allocator<_Container, _Alloc>::value, int> >
874_LIBCPP_CONSTEXPR_SINCE_CXX26 inline priority_queue<_Tp, _Container, _Compare>::priority_queue(
875 _InputIter __f, _InputIter __l, const _Alloc& __a)
876 : c(__f, __l, __a), comp() {
877 std::make_heap(c.begin(), c.end(), comp);
878}
879
880template <class _Tp, class _Container, class _Compare>
881template <
882 class _InputIter,
883 class _Alloc,
884 __enable_if_t<__has_input_iterator_category<_InputIter>::value && uses_allocator<_Container, _Alloc>::value, int> >
885_LIBCPP_CONSTEXPR_SINCE_CXX26 inline priority_queue<_Tp, _Container, _Compare>::priority_queue(
886 _InputIter __f, _InputIter __l, const value_compare& __comp, const _Alloc& __a)
887 : c(__f, __l, __a), comp(__comp) {
888 std::make_heap(c.begin(), c.end(), comp);
889}
890
891template <class _Tp, class _Container, class _Compare>
892template <
893 class _InputIter,
894 class _Alloc,
895 __enable_if_t<__has_input_iterator_category<_InputIter>::value && uses_allocator<_Container, _Alloc>::value, int> >
896_LIBCPP_CONSTEXPR_SINCE_CXX26 inline priority_queue<_Tp, _Container, _Compare>::priority_queue(
897 _InputIter __f, _InputIter __l, const value_compare& __comp, const container_type& __c, const _Alloc& __a)
898 : c(__c, __a), comp(__comp) {
899 c.insert(c.end(), __f, __l);
900 std::make_heap(c.begin(), c.end(), comp);
901}
902
903# ifndef _LIBCPP_CXX03_LANG
904template <class _Tp, class _Container, class _Compare>
905template <
906 class _InputIter,
907 class _Alloc,
908 __enable_if_t<__has_input_iterator_category<_InputIter>::value && uses_allocator<_Container, _Alloc>::value, int> >
909_LIBCPP_CONSTEXPR_SINCE_CXX26 inline priority_queue<_Tp, _Container, _Compare>::priority_queue(
910 _InputIter __f, _InputIter __l, const value_compare& __comp, container_type&& __c, const _Alloc& __a)
911 : c(std::move(__c), __a), comp(__comp) {
912 c.insert(c.end(), __f, __l);
913 std::make_heap(c.begin(), c.end(), comp);
914}
915# endif // _LIBCPP_CXX03_LANG
916
917template <class _Tp, class _Container, class _Compare>
918_LIBCPP_CONSTEXPR_SINCE_CXX26 inline void priority_queue<_Tp, _Container, _Compare>::push(const value_type& __v) {
919 c.push_back(__v);
920 std::push_heap(c.begin(), c.end(), comp);
921}
922
923# ifndef _LIBCPP_CXX03_LANG
924
925template <class _Tp, class _Container, class _Compare>
926_LIBCPP_CONSTEXPR_SINCE_CXX26 inline void priority_queue<_Tp, _Container, _Compare>::push(value_type&& __v) {
927 c.push_back(std::move(__v));
928 std::push_heap(c.begin(), c.end(), comp);
929}
930
931template <class _Tp, class _Container, class _Compare>
932template <class... _Args>
933_LIBCPP_CONSTEXPR_SINCE_CXX26 inline void priority_queue<_Tp, _Container, _Compare>::emplace(_Args&&... __args) {
934 c.emplace_back(std::forward<_Args>(__args)...);
935 std::push_heap(c.begin(), c.end(), comp);
936}
937
938# endif // _LIBCPP_CXX03_LANG
939
940template <class _Tp, class _Container, class _Compare>
941_LIBCPP_CONSTEXPR_SINCE_CXX26 inline void priority_queue<_Tp, _Container, _Compare>::pop() {
942 std::pop_heap(c.begin(), c.end(), comp);
943 c.pop_back();
944}
945
946template <class _Tp, class _Container, class _Compare>
947_LIBCPP_CONSTEXPR_SINCE_CXX26 inline void priority_queue<_Tp, _Container, _Compare>::swap(priority_queue& __q)
948 _NOEXCEPT_(__is_nothrow_swappable_v<container_type>&& __is_nothrow_swappable_v<value_compare>) {
949 using std::swap;
950 swap(c, __q.c);
951 swap(comp, __q.comp);
952}
953
954template <class _Tp,
955 class _Container,
956 class _Compare,
957 __enable_if_t<__is_swappable_v<_Container> && __is_swappable_v<_Compare>, int> = 0>
958_LIBCPP_CONSTEXPR_SINCE_CXX26 inline _LIBCPP_HIDE_FROM_ABI void
959swap(priority_queue<_Tp, _Container, _Compare>& __x, priority_queue<_Tp, _Container, _Compare>& __y)
960 _NOEXCEPT_(_NOEXCEPT_(__x.swap(__y))) {
961 __x.swap(__y);
962}
963
964template <class _Tp, class _Container, class _Compare, class _Alloc>
965struct uses_allocator<priority_queue<_Tp, _Container, _Compare>, _Alloc> : public uses_allocator<_Container, _Alloc> {};
966
967_LIBCPP_END_NAMESPACE_STD
968
969_LIBCPP_POP_MACROS
970
971# if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
972# include <concepts>
973# include <cstdlib>
974# include <functional>
975# include <type_traits>
976# endif
977#endif // __cplusplus < 201103L && defined(_LIBCPP_USE_FROZEN_CXX03_HEADERS)
978
979#endif // _LIBCPP_QUEUE