2 //===--------------------------- queue ------------------------------------===//
4 // The LLVM Compiler Infrastructure
6 // This file is dual licensed under the MIT and the University of Illinois Open
7 // Source Licenses. See LICENSE.TXT for details.
9 //===----------------------------------------------------------------------===//
20 template <class T, class Container = deque<T>>
24 typedef Container container_type;
25 typedef typename container_type::value_type value_type;
26 typedef typename container_type::reference reference;
27 typedef typename container_type::const_reference const_reference;
28 typedef typename container_type::size_type size_type;
37 queue(const queue& q) = default;
38 queue(queue&& q) = default;
40 queue& operator=(const queue& q) = default;
41 queue& operator=(queue&& q) = default;
43 explicit queue(const container_type& c);
44 explicit queue(container_type&& c)
45 template <class Alloc>
46 explicit queue(const Alloc& a);
47 template <class Alloc>
48 queue(const container_type& c, const Alloc& a);
49 template <class Alloc>
50 queue(container_type&& c, const Alloc& a);
51 template <class Alloc>
52 queue(const queue& q, const Alloc& a);
53 template <class Alloc>
54 queue(queue&& q, const Alloc& a);
57 size_type size() const;
60 const_reference front() const;
62 const_reference back() const;
64 void push(const value_type& v);
65 void push(value_type&& v);
66 template <class... Args> void emplace(Args&&... args);
69 void swap(queue& q) noexcept(is_nothrow_swappable_v<Container>)
72 template <class T, class Container>
73 bool operator==(const queue<T, Container>& x,const queue<T, Container>& y);
75 template <class T, class Container>
76 bool operator< (const queue<T, Container>& x,const queue<T, Container>& y);
78 template <class T, class Container>
79 bool operator!=(const queue<T, Container>& x,const queue<T, Container>& y);
81 template <class T, class Container>
82 bool operator> (const queue<T, Container>& x,const queue<T, Container>& y);
84 template <class T, class Container>
85 bool operator>=(const queue<T, Container>& x,const queue<T, Container>& y);
87 template <class T, class Container>
88 bool operator<=(const queue<T, Container>& x,const queue<T, Container>& y);
90 template <class T, class Container>
91 void swap(queue<T, Container>& x, queue<T, Container>& y)
92 noexcept(noexcept(x.swap(y)));
94 template <class T, class Container = vector<T>,
95 class Compare = less<typename Container::value_type>>
99 typedef Container container_type;
100 typedef typename container_type::value_type value_type;
101 typedef typename container_type::reference reference;
102 typedef typename container_type::const_reference const_reference;
103 typedef typename container_type::size_type size_type;
110 priority_queue() = default;
111 ~priority_queue() = default;
113 priority_queue(const priority_queue& q) = default;
114 priority_queue(priority_queue&& q) = default;
116 priority_queue& operator=(const priority_queue& q) = default;
117 priority_queue& operator=(priority_queue&& q) = default;
119 explicit priority_queue(const Compare& comp);
120 priority_queue(const Compare& comp, const container_type& c);
121 explicit priority_queue(const Compare& comp, container_type&& c);
122 template <class InputIterator>
123 priority_queue(InputIterator first, InputIterator last,
124 const Compare& comp = Compare());
125 template <class InputIterator>
126 priority_queue(InputIterator first, InputIterator last,
127 const Compare& comp, const container_type& c);
128 template <class InputIterator>
129 priority_queue(InputIterator first, InputIterator last,
130 const Compare& comp, container_type&& c);
131 template <class Alloc>
132 explicit priority_queue(const Alloc& a);
133 template <class Alloc>
134 priority_queue(const Compare& comp, const Alloc& a);
135 template <class Alloc>
136 priority_queue(const Compare& comp, const container_type& c,
138 template <class Alloc>
139 priority_queue(const Compare& comp, container_type&& c,
141 template <class Alloc>
142 priority_queue(const priority_queue& q, const Alloc& a);
143 template <class Alloc>
144 priority_queue(priority_queue&& q, const Alloc& a);
147 size_type size() const;
148 const_reference top() const;
150 void push(const value_type& v);
151 void push(value_type&& v);
152 template <class... Args> void emplace(Args&&... args);
155 void swap(priority_queue& q)
156 noexcept(is_nothrow_swappable_v<Container> &&
157 is_nothrow_swappable_v<Comp>)
160 template <class T, class Container, class Compare>
161 void swap(priority_queue<T, Container, Compare>& x,
162 priority_queue<T, Container, Compare>& y)
163 noexcept(noexcept(x.swap(y)));
172 #include <functional>
175 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
176 #pragma GCC system_header
179 _LIBCPP_BEGIN_NAMESPACE_STD
181 template <class _Tp, class _Container = deque<_Tp> > class _LIBCPP_TYPE_VIS_ONLY queue;
183 template <class _Tp, class _Container>
184 _LIBCPP_INLINE_VISIBILITY
186 operator==(const queue<_Tp, _Container>& __x,const queue<_Tp, _Container>& __y);
188 template <class _Tp, class _Container>
189 _LIBCPP_INLINE_VISIBILITY
191 operator< (const queue<_Tp, _Container>& __x,const queue<_Tp, _Container>& __y);
193 template <class _Tp, class _Container /*= deque<_Tp>*/>
194 class _LIBCPP_TYPE_VIS_ONLY queue
197 typedef _Container container_type;
198 typedef typename container_type::value_type value_type;
199 typedef typename container_type::reference reference;
200 typedef typename container_type::const_reference const_reference;
201 typedef typename container_type::size_type size_type;
202 static_assert((is_same<_Tp, value_type>::value), "" );
208 _LIBCPP_INLINE_VISIBILITY
210 _NOEXCEPT_(is_nothrow_default_constructible<container_type>::value)
213 _LIBCPP_INLINE_VISIBILITY
214 queue(const queue& __q) : c(__q.c) {}
216 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
217 _LIBCPP_INLINE_VISIBILITY
219 _NOEXCEPT_(is_nothrow_move_constructible<container_type>::value)
220 : c(_VSTD::move(__q.c)) {}
221 #endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
223 _LIBCPP_INLINE_VISIBILITY
224 queue& operator=(const queue& __q) {c = __q.c; return *this;}
226 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
227 _LIBCPP_INLINE_VISIBILITY
228 queue& operator=(queue&& __q)
229 _NOEXCEPT_(is_nothrow_move_assignable<container_type>::value)
230 {c = _VSTD::move(__q.c); return *this;}
231 #endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
233 _LIBCPP_INLINE_VISIBILITY
234 explicit queue(const container_type& __c) : c(__c) {}
235 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
236 _LIBCPP_INLINE_VISIBILITY
237 explicit queue(container_type&& __c) : c(_VSTD::move(__c)) {}
238 #endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
239 template <class _Alloc>
240 _LIBCPP_INLINE_VISIBILITY
241 explicit queue(const _Alloc& __a,
242 typename enable_if<uses_allocator<container_type,
243 _Alloc>::value>::type* = 0)
245 template <class _Alloc>
246 _LIBCPP_INLINE_VISIBILITY
247 queue(const queue& __q, const _Alloc& __a,
248 typename enable_if<uses_allocator<container_type,
249 _Alloc>::value>::type* = 0)
251 template <class _Alloc>
252 _LIBCPP_INLINE_VISIBILITY
253 queue(const container_type& __c, const _Alloc& __a,
254 typename enable_if<uses_allocator<container_type,
255 _Alloc>::value>::type* = 0)
257 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
258 template <class _Alloc>
259 _LIBCPP_INLINE_VISIBILITY
260 queue(container_type&& __c, const _Alloc& __a,
261 typename enable_if<uses_allocator<container_type,
262 _Alloc>::value>::type* = 0)
263 : c(_VSTD::move(__c), __a) {}
264 template <class _Alloc>
265 _LIBCPP_INLINE_VISIBILITY
266 queue(queue&& __q, const _Alloc& __a,
267 typename enable_if<uses_allocator<container_type,
268 _Alloc>::value>::type* = 0)
269 : c(_VSTD::move(__q.c), __a) {}
271 #endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
273 _LIBCPP_INLINE_VISIBILITY
274 bool empty() const {return c.empty();}
275 _LIBCPP_INLINE_VISIBILITY
276 size_type size() const {return c.size();}
278 _LIBCPP_INLINE_VISIBILITY
279 reference front() {return c.front();}
280 _LIBCPP_INLINE_VISIBILITY
281 const_reference front() const {return c.front();}
282 _LIBCPP_INLINE_VISIBILITY
283 reference back() {return c.back();}
284 _LIBCPP_INLINE_VISIBILITY
285 const_reference back() const {return c.back();}
287 _LIBCPP_INLINE_VISIBILITY
288 void push(const value_type& __v) {c.push_back(__v);}
289 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
290 _LIBCPP_INLINE_VISIBILITY
291 void push(value_type&& __v) {c.push_back(_VSTD::move(__v));}
292 #ifndef _LIBCPP_HAS_NO_VARIADICS
293 template <class... _Args>
294 _LIBCPP_INLINE_VISIBILITY
295 void emplace(_Args&&... __args)
296 {c.emplace_back(_VSTD::forward<_Args>(__args)...);}
297 #endif // _LIBCPP_HAS_NO_VARIADICS
298 #endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
299 _LIBCPP_INLINE_VISIBILITY
300 void pop() {c.pop_front();}
302 _LIBCPP_INLINE_VISIBILITY
303 void swap(queue& __q)
304 _NOEXCEPT_(__is_nothrow_swappable<container_type>::value)
310 template <class _T1, class _C1>
312 _LIBCPP_INLINE_VISIBILITY
314 operator==(const queue<_T1, _C1>& __x,const queue<_T1, _C1>& __y);
316 template <class _T1, class _C1>
318 _LIBCPP_INLINE_VISIBILITY
320 operator< (const queue<_T1, _C1>& __x,const queue<_T1, _C1>& __y);
323 template <class _Tp, class _Container>
324 inline _LIBCPP_INLINE_VISIBILITY
326 operator==(const queue<_Tp, _Container>& __x,const queue<_Tp, _Container>& __y)
328 return __x.c == __y.c;
331 template <class _Tp, class _Container>
332 inline _LIBCPP_INLINE_VISIBILITY
334 operator< (const queue<_Tp, _Container>& __x,const queue<_Tp, _Container>& __y)
336 return __x.c < __y.c;
339 template <class _Tp, class _Container>
340 inline _LIBCPP_INLINE_VISIBILITY
342 operator!=(const queue<_Tp, _Container>& __x,const queue<_Tp, _Container>& __y)
344 return !(__x == __y);
347 template <class _Tp, class _Container>
348 inline _LIBCPP_INLINE_VISIBILITY
350 operator> (const queue<_Tp, _Container>& __x,const queue<_Tp, _Container>& __y)
355 template <class _Tp, class _Container>
356 inline _LIBCPP_INLINE_VISIBILITY
358 operator>=(const queue<_Tp, _Container>& __x,const queue<_Tp, _Container>& __y)
363 template <class _Tp, class _Container>
364 inline _LIBCPP_INLINE_VISIBILITY
366 operator<=(const queue<_Tp, _Container>& __x,const queue<_Tp, _Container>& __y)
371 template <class _Tp, class _Container>
372 inline _LIBCPP_INLINE_VISIBILITY
374 __is_swappable<_Container>::value,
377 swap(queue<_Tp, _Container>& __x, queue<_Tp, _Container>& __y)
378 _NOEXCEPT_(_NOEXCEPT_(__x.swap(__y)))
383 template <class _Tp, class _Container, class _Alloc>
384 struct _LIBCPP_TYPE_VIS_ONLY uses_allocator<queue<_Tp, _Container>, _Alloc>
385 : public uses_allocator<_Container, _Alloc>
389 template <class _Tp, class _Container = vector<_Tp>,
390 class _Compare = less<typename _Container::value_type> >
391 class _LIBCPP_TYPE_VIS_ONLY priority_queue
394 typedef _Container container_type;
395 typedef _Compare value_compare;
396 typedef typename container_type::value_type value_type;
397 typedef typename container_type::reference reference;
398 typedef typename container_type::const_reference const_reference;
399 typedef typename container_type::size_type size_type;
400 static_assert((is_same<_Tp, value_type>::value), "" );
407 _LIBCPP_INLINE_VISIBILITY
409 _NOEXCEPT_(is_nothrow_default_constructible<container_type>::value &&
410 is_nothrow_default_constructible<value_compare>::value)
413 _LIBCPP_INLINE_VISIBILITY
414 priority_queue(const priority_queue& __q) : c(__q.c), comp(__q.comp) {}
416 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
417 _LIBCPP_INLINE_VISIBILITY
418 priority_queue(priority_queue&& __q)
419 _NOEXCEPT_(is_nothrow_move_constructible<container_type>::value &&
420 is_nothrow_move_constructible<value_compare>::value)
421 : c(_VSTD::move(__q.c)), comp(_VSTD::move(__q.comp)) {}
422 #endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
424 _LIBCPP_INLINE_VISIBILITY
425 priority_queue& operator=(const priority_queue& __q)
426 {c = __q.c; comp = __q.comp; return *this;}
428 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
429 _LIBCPP_INLINE_VISIBILITY
430 priority_queue& operator=(priority_queue&& __q)
431 _NOEXCEPT_(is_nothrow_move_assignable<container_type>::value &&
432 is_nothrow_move_assignable<value_compare>::value)
433 {c = _VSTD::move(__q.c); comp = _VSTD::move(__q.comp); return *this;}
434 #endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
436 _LIBCPP_INLINE_VISIBILITY
437 explicit priority_queue(const value_compare& __comp)
438 : c(), comp(__comp) {}
439 _LIBCPP_INLINE_VISIBILITY
440 priority_queue(const value_compare& __comp, const container_type& __c);
441 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
442 _LIBCPP_INLINE_VISIBILITY
443 explicit priority_queue(const value_compare& __comp, container_type&& __c);
445 template <class _InputIter>
446 _LIBCPP_INLINE_VISIBILITY
447 priority_queue(_InputIter __f, _InputIter __l,
448 const value_compare& __comp = value_compare());
449 template <class _InputIter>
450 _LIBCPP_INLINE_VISIBILITY
451 priority_queue(_InputIter __f, _InputIter __l,
452 const value_compare& __comp, const container_type& __c);
453 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
454 template <class _InputIter>
455 _LIBCPP_INLINE_VISIBILITY
456 priority_queue(_InputIter __f, _InputIter __l,
457 const value_compare& __comp, container_type&& __c);
458 #endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
459 template <class _Alloc>
460 _LIBCPP_INLINE_VISIBILITY
461 explicit priority_queue(const _Alloc& __a,
462 typename enable_if<uses_allocator<container_type,
463 _Alloc>::value>::type* = 0);
464 template <class _Alloc>
465 _LIBCPP_INLINE_VISIBILITY
466 priority_queue(const value_compare& __comp, const _Alloc& __a,
467 typename enable_if<uses_allocator<container_type,
468 _Alloc>::value>::type* = 0);
469 template <class _Alloc>
470 _LIBCPP_INLINE_VISIBILITY
471 priority_queue(const value_compare& __comp, const container_type& __c,
473 typename enable_if<uses_allocator<container_type,
474 _Alloc>::value>::type* = 0);
475 template <class _Alloc>
476 _LIBCPP_INLINE_VISIBILITY
477 priority_queue(const priority_queue& __q, const _Alloc& __a,
478 typename enable_if<uses_allocator<container_type,
479 _Alloc>::value>::type* = 0);
480 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
481 template <class _Alloc>
482 _LIBCPP_INLINE_VISIBILITY
483 priority_queue(const value_compare& __comp, container_type&& __c,
485 typename enable_if<uses_allocator<container_type,
486 _Alloc>::value>::type* = 0);
487 template <class _Alloc>
488 _LIBCPP_INLINE_VISIBILITY
489 priority_queue(priority_queue&& __q, const _Alloc& __a,
490 typename enable_if<uses_allocator<container_type,
491 _Alloc>::value>::type* = 0);
492 #endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
494 _LIBCPP_INLINE_VISIBILITY
495 bool empty() const {return c.empty();}
496 _LIBCPP_INLINE_VISIBILITY
497 size_type size() const {return c.size();}
498 _LIBCPP_INLINE_VISIBILITY
499 const_reference top() const {return c.front();}
501 _LIBCPP_INLINE_VISIBILITY
502 void push(const value_type& __v);
503 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
504 _LIBCPP_INLINE_VISIBILITY
505 void push(value_type&& __v);
506 #ifndef _LIBCPP_HAS_NO_VARIADICS
507 template <class... _Args> _LIBCPP_INLINE_VISIBILITY void emplace(_Args&&... __args);
509 #endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
510 _LIBCPP_INLINE_VISIBILITY
513 _LIBCPP_INLINE_VISIBILITY
514 void swap(priority_queue& __q)
515 _NOEXCEPT_(__is_nothrow_swappable<container_type>::value &&
516 __is_nothrow_swappable<value_compare>::value);
519 template <class _Tp, class _Container, class _Compare>
521 priority_queue<_Tp, _Container, _Compare>::priority_queue(const _Compare& __comp,
522 const container_type& __c)
526 _VSTD::make_heap(c.begin(), c.end(), comp);
529 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
531 template <class _Tp, class _Container, class _Compare>
533 priority_queue<_Tp, _Container, _Compare>::priority_queue(const value_compare& __comp,
534 container_type&& __c)
535 : c(_VSTD::move(__c)),
538 _VSTD::make_heap(c.begin(), c.end(), comp);
541 #endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
543 template <class _Tp, class _Container, class _Compare>
544 template <class _InputIter>
546 priority_queue<_Tp, _Container, _Compare>::priority_queue(_InputIter __f, _InputIter __l,
547 const value_compare& __comp)
551 _VSTD::make_heap(c.begin(), c.end(), comp);
554 template <class _Tp, class _Container, class _Compare>
555 template <class _InputIter>
557 priority_queue<_Tp, _Container, _Compare>::priority_queue(_InputIter __f, _InputIter __l,
558 const value_compare& __comp,
559 const container_type& __c)
563 c.insert(c.end(), __f, __l);
564 _VSTD::make_heap(c.begin(), c.end(), comp);
567 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
569 template <class _Tp, class _Container, class _Compare>
570 template <class _InputIter>
572 priority_queue<_Tp, _Container, _Compare>::priority_queue(_InputIter __f, _InputIter __l,
573 const value_compare& __comp,
574 container_type&& __c)
575 : c(_VSTD::move(__c)),
578 c.insert(c.end(), __f, __l);
579 _VSTD::make_heap(c.begin(), c.end(), comp);
582 #endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
584 template <class _Tp, class _Container, class _Compare>
585 template <class _Alloc>
587 priority_queue<_Tp, _Container, _Compare>::priority_queue(const _Alloc& __a,
588 typename enable_if<uses_allocator<container_type,
589 _Alloc>::value>::type*)
594 template <class _Tp, class _Container, class _Compare>
595 template <class _Alloc>
597 priority_queue<_Tp, _Container, _Compare>::priority_queue(const value_compare& __comp,
599 typename enable_if<uses_allocator<container_type,
600 _Alloc>::value>::type*)
606 template <class _Tp, class _Container, class _Compare>
607 template <class _Alloc>
609 priority_queue<_Tp, _Container, _Compare>::priority_queue(const value_compare& __comp,
610 const container_type& __c,
612 typename enable_if<uses_allocator<container_type,
613 _Alloc>::value>::type*)
617 _VSTD::make_heap(c.begin(), c.end(), comp);
620 template <class _Tp, class _Container, class _Compare>
621 template <class _Alloc>
623 priority_queue<_Tp, _Container, _Compare>::priority_queue(const priority_queue& __q,
625 typename enable_if<uses_allocator<container_type,
626 _Alloc>::value>::type*)
630 _VSTD::make_heap(c.begin(), c.end(), comp);
633 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
635 template <class _Tp, class _Container, class _Compare>
636 template <class _Alloc>
638 priority_queue<_Tp, _Container, _Compare>::priority_queue(const value_compare& __comp,
639 container_type&& __c,
641 typename enable_if<uses_allocator<container_type,
642 _Alloc>::value>::type*)
643 : c(_VSTD::move(__c), __a),
646 _VSTD::make_heap(c.begin(), c.end(), comp);
649 template <class _Tp, class _Container, class _Compare>
650 template <class _Alloc>
652 priority_queue<_Tp, _Container, _Compare>::priority_queue(priority_queue&& __q,
654 typename enable_if<uses_allocator<container_type,
655 _Alloc>::value>::type*)
656 : c(_VSTD::move(__q.c), __a),
657 comp(_VSTD::move(__q.comp))
659 _VSTD::make_heap(c.begin(), c.end(), comp);
662 #endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
664 template <class _Tp, class _Container, class _Compare>
667 priority_queue<_Tp, _Container, _Compare>::push(const value_type& __v)
670 _VSTD::push_heap(c.begin(), c.end(), comp);
673 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
675 template <class _Tp, class _Container, class _Compare>
678 priority_queue<_Tp, _Container, _Compare>::push(value_type&& __v)
680 c.push_back(_VSTD::move(__v));
681 _VSTD::push_heap(c.begin(), c.end(), comp);
684 #ifndef _LIBCPP_HAS_NO_VARIADICS
686 template <class _Tp, class _Container, class _Compare>
687 template <class... _Args>
690 priority_queue<_Tp, _Container, _Compare>::emplace(_Args&&... __args)
692 c.emplace_back(_VSTD::forward<_Args>(__args)...);
693 _VSTD::push_heap(c.begin(), c.end(), comp);
696 #endif // _LIBCPP_HAS_NO_VARIADICS
697 #endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
699 template <class _Tp, class _Container, class _Compare>
702 priority_queue<_Tp, _Container, _Compare>::pop()
704 _VSTD::pop_heap(c.begin(), c.end(), comp);
708 template <class _Tp, class _Container, class _Compare>
711 priority_queue<_Tp, _Container, _Compare>::swap(priority_queue& __q)
712 _NOEXCEPT_(__is_nothrow_swappable<container_type>::value &&
713 __is_nothrow_swappable<value_compare>::value)
717 swap(comp, __q.comp);
720 template <class _Tp, class _Container, class _Compare>
721 inline _LIBCPP_INLINE_VISIBILITY
723 __is_swappable<_Container>::value
724 && __is_swappable<_Compare>::value,
727 swap(priority_queue<_Tp, _Container, _Compare>& __x,
728 priority_queue<_Tp, _Container, _Compare>& __y)
729 _NOEXCEPT_(_NOEXCEPT_(__x.swap(__y)))
734 template <class _Tp, class _Container, class _Compare, class _Alloc>
735 struct _LIBCPP_TYPE_VIS_ONLY uses_allocator<priority_queue<_Tp, _Container, _Compare>, _Alloc>
736 : public uses_allocator<_Container, _Alloc>
740 _LIBCPP_END_NAMESPACE_STD
742 #endif // _LIBCPP_QUEUE