57 #define _STL_QUEUE_H 1 61 #if __cplusplus >= 201103L 62 # include <bits/uses_allocator.h> 65 namespace std _GLIBCXX_VISIBILITY(default)
67 _GLIBCXX_BEGIN_NAMESPACE_VERSION
95 template<
typename _Tp,
typename _Sequence = deque<_Tp> >
99 typedef typename _Sequence::value_type _Sequence_value_type;
100 __glibcxx_class_requires(_Tp, _SGIAssignableConcept)
101 __glibcxx_class_requires(_Sequence, _FrontInsertionSequenceConcept)
102 __glibcxx_class_requires(_Sequence, _BackInsertionSequenceConcept)
103 __glibcxx_class_requires2(_Tp, _Sequence_value_type, _SameTypeConcept)
105 template<
typename _Tp1,
typename _Seq1>
109 template<
typename _Tp1,
typename _Seq1>
113 #if __cplusplus >= 201103L 114 template<
typename _Alloc>
115 using _Uses =
typename 116 enable_if<uses_allocator<_Sequence, _Alloc>::value>::type;
120 typedef typename _Sequence::value_type value_type;
121 typedef typename _Sequence::reference reference;
122 typedef typename _Sequence::const_reference const_reference;
123 typedef typename _Sequence::size_type size_type;
124 typedef _Sequence container_type;
141 #if __cplusplus < 201103L 143 queue(
const _Sequence& __c = _Sequence())
146 template<
typename _Seq = _Sequence,
typename _Requires =
typename 147 enable_if<is_default_constructible<_Seq>::value>::type>
152 queue(
const _Sequence& __c)
156 queue(_Sequence&& __c)
157 :
c(std::move(__c)) { }
159 template<
typename _Alloc,
typename _Requires = _Uses<_Alloc>>
161 queue(
const _Alloc& __a)
164 template<
typename _Alloc,
typename _Requires = _Uses<_Alloc>>
165 queue(
const _Sequence& __c,
const _Alloc& __a)
168 template<
typename _Alloc,
typename _Requires = _Uses<_Alloc>>
169 queue(_Sequence&& __c,
const _Alloc& __a)
170 :
c(std::move(__c), __a) { }
172 template<
typename _Alloc,
typename _Requires = _Uses<_Alloc>>
176 template<
typename _Alloc,
typename _Requires = _Uses<_Alloc>>
178 :
c(std::move(__q.
c), __a) { }
186 {
return c.empty(); }
200 __glibcxx_requires_nonempty();
211 __glibcxx_requires_nonempty();
222 __glibcxx_requires_nonempty();
233 __glibcxx_requires_nonempty();
248 { c.push_back(__x); }
250 #if __cplusplus >= 201103L 252 push(value_type&& __x)
253 { c.push_back(std::move(__x)); }
255 #if __cplusplus > 201402L 256 template<
typename... _Args>
258 emplace(_Args&&... __args)
259 {
return c.emplace_back(std::forward<_Args>(__args)...); }
261 template<
typename... _Args>
263 emplace(_Args&&... __args)
264 { c.emplace_back(std::forward<_Args>(__args)...); }
282 __glibcxx_requires_nonempty();
286 #if __cplusplus >= 201103L 289 #if __cplusplus > 201402L || !defined(__STRICT_ANSI__) // c++1z or gnu++11 290 noexcept(__is_nothrow_swappable<_Sequence>::value)
292 noexcept(__is_nothrow_swappable<_Tp>::value)
298 #endif // __cplusplus >= 201103L 312 template<
typename _Tp,
typename _Seq>
315 {
return __x.
c == __y.
c; }
330 template<
typename _Tp,
typename _Seq>
333 {
return __x.
c < __y.c; }
336 template<
typename _Tp,
typename _Seq>
339 {
return !(__x == __y); }
342 template<
typename _Tp,
typename _Seq>
345 {
return __y < __x; }
348 template<
typename _Tp,
typename _Seq>
351 {
return !(__y < __x); }
354 template<
typename _Tp,
typename _Seq>
357 {
return !(__x < __y); }
359 #if __cplusplus >= 201103L 360 template<
typename _Tp,
typename _Seq>
362 #if __cplusplus > 201402L || !defined(__STRICT_ANSI__) // c++1z or gnu++11 364 typename enable_if<__is_swappable<_Seq>::value>::type
369 noexcept(noexcept(__x.swap(__y)))
372 template<
typename _Tp,
typename _Seq,
typename _Alloc>
375 #endif // __cplusplus >= 201103L 417 template<
typename _Tp,
typename _Sequence = vector<_Tp>,
418 typename _Compare = less<
typename _Sequence::value_type> >
422 typedef typename _Sequence::value_type _Sequence_value_type;
423 __glibcxx_class_requires(_Tp, _SGIAssignableConcept)
424 __glibcxx_class_requires(_Sequence, _SequenceConcept)
425 __glibcxx_class_requires(_Sequence, _RandomAccessContainerConcept)
426 __glibcxx_class_requires2(_Tp, _Sequence_value_type, _SameTypeConcept)
427 __glibcxx_class_requires4(_Compare,
bool, _Tp, _Tp,
428 _BinaryFunctionConcept)
430 #if __cplusplus >= 201103L 431 template<
typename _Alloc>
432 using _Uses =
typename 433 enable_if<uses_allocator<_Sequence, _Alloc>::value>::type;
437 typedef typename _Sequence::value_type value_type;
438 typedef typename _Sequence::reference reference;
439 typedef typename _Sequence::const_reference const_reference;
440 typedef typename _Sequence::size_type size_type;
441 typedef _Sequence container_type;
444 typedef _Compare value_compare;
455 #if __cplusplus < 201103L 458 const _Sequence& __s = _Sequence())
462 template<
typename _Seq = _Sequence,
typename _Requires =
typename 463 enable_if<__and_<is_default_constructible<_Compare>,
464 is_default_constructible<_Seq>>::value>::type>
474 priority_queue(
const _Compare& __x, _Sequence&& __s = _Sequence())
475 :
c(std::move(__s)), comp(__x)
478 template<
typename _Alloc,
typename _Requires = _Uses<_Alloc>>
480 priority_queue(
const _Alloc& __a)
483 template<
typename _Alloc,
typename _Requires = _Uses<_Alloc>>
484 priority_queue(
const _Compare& __x,
const _Alloc& __a)
485 :
c(__a), comp(__x) { }
487 template<
typename _Alloc,
typename _Requires = _Uses<_Alloc>>
488 priority_queue(
const _Compare& __x,
const _Sequence& __c,
490 :
c(__c, __a), comp(__x) { }
492 template<
typename _Alloc,
typename _Requires = _Uses<_Alloc>>
493 priority_queue(
const _Compare& __x, _Sequence&& __c,
const _Alloc& __a)
494 :
c(std::move(__c), __a), comp(__x) { }
496 template<
typename _Alloc,
typename _Requires = _Uses<_Alloc>>
497 priority_queue(
const priority_queue& __q,
const _Alloc& __a)
498 :
c(__q.c, __a), comp(__q.comp) { }
500 template<
typename _Alloc,
typename _Requires = _Uses<_Alloc>>
501 priority_queue(priority_queue&& __q,
const _Alloc& __a)
502 :
c(std::move(__q.c), __a), comp(std::move(__q.comp)) { }
520 #if __cplusplus < 201103L 521 template<
typename _InputIterator>
522 priority_queue(_InputIterator __first, _InputIterator __last,
523 const _Compare& __x = _Compare(),
524 const _Sequence& __s = _Sequence())
527 __glibcxx_requires_valid_range(__first, __last);
528 c.insert(c.end(), __first, __last);
532 template<
typename _InputIterator>
535 const _Sequence& __s)
538 __glibcxx_requires_valid_range(__first, __last);
539 c.insert(c.end(), __first, __last);
543 template<
typename _InputIterator>
544 priority_queue(_InputIterator __first, _InputIterator __last,
545 const _Compare& __x = _Compare(),
546 _Sequence&& __s = _Sequence())
547 :
c(std::move(__s)), comp(__x)
549 __glibcxx_requires_valid_range(__first, __last);
550 c.insert(c.end(), __first, __last);
560 {
return c.empty(); }
574 __glibcxx_requires_nonempty();
593 #if __cplusplus >= 201103L 595 push(value_type&& __x)
597 c.push_back(std::move(__x));
601 template<
typename... _Args>
603 emplace(_Args&&... __args)
605 c.emplace_back(std::forward<_Args>(__args)...);
624 __glibcxx_requires_nonempty();
629 #if __cplusplus >= 201103L 631 swap(priority_queue& __pq)
633 #
if __cplusplus > 201402L || !defined(__STRICT_ANSI__)
634 __is_nothrow_swappable<_Sequence>,
636 __is_nothrow_swappable<_Tp>,
638 __is_nothrow_swappable<_Compare>
643 swap(comp, __pq.comp);
645 #endif // __cplusplus >= 201103L 650 #if __cplusplus >= 201103L 651 template<
typename _Tp,
typename _Sequence,
typename _Compare>
653 #if __cplusplus > 201402L || !defined(__STRICT_ANSI__) // c++1z or gnu++11 655 typename enable_if<__and_<__is_swappable<_Sequence>,
656 __is_swappable<_Compare>>::value>::type
662 noexcept(noexcept(__x.swap(__y)))
665 template<
typename _Tp,
typename _Sequence,
typename _Compare,
667 struct uses_allocator<priority_queue<_Tp, _Sequence, _Compare>, _Alloc>
669 #endif // __cplusplus >= 201103L 671 _GLIBCXX_END_NAMESPACE_VERSION
void pop()
Removes first element.
void push_heap(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp)
Push an element onto a heap using comparison functor.
ISO C++ entities toplevel namespace is std.
priority_queue()
Default constructor creates no elements.
queue()
Default constructor creates no elements.
void make_heap(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp)
Construct a heap over a range using comparison functor.
_Sequence c
c is the underlying container.
priority_queue(_InputIterator __first, _InputIterator __last, const _Compare &__x, const _Sequence &__s)
Builds a queue from a range.
A standard container giving FIFO behavior.
const_reference front() const
const_reference back() const
Declare uses_allocator so it can be specialized in <queue> etc.
void push(const value_type &__x)
Add data to the queue.
A standard container automatically sorting its contents.
void pop()
Removes first element.
void push(const value_type &__x)
Add data to the end of the queue.
const_reference top() const
void pop_heap(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp)
Pop an element off a heap using comparison functor.