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())
151 queue(_Sequence&& __c = _Sequence())
152 :
c(std::move(__c)) { }
154 template<
typename _Alloc,
typename _Requires = _Uses<_Alloc>>
156 queue(
const _Alloc& __a)
159 template<
typename _Alloc,
typename _Requires = _Uses<_Alloc>>
160 queue(
const _Sequence& __c,
const _Alloc& __a)
163 template<
typename _Alloc,
typename _Requires = _Uses<_Alloc>>
164 queue(_Sequence&& __c,
const _Alloc& __a)
165 :
c(std::move(__c), __a) { }
167 template<
typename _Alloc,
typename _Requires = _Uses<_Alloc>>
171 template<
typename _Alloc,
typename _Requires = _Uses<_Alloc>>
173 :
c(std::move(__q.
c), __a) { }
181 {
return c.empty(); }
195 __glibcxx_requires_nonempty();
206 __glibcxx_requires_nonempty();
217 __glibcxx_requires_nonempty();
228 __glibcxx_requires_nonempty();
243 { c.push_back(__x); }
245 #if __cplusplus >= 201103L 247 push(value_type&& __x)
248 { c.push_back(std::move(__x)); }
250 #if __cplusplus > 201402L 251 template<
typename... _Args>
253 emplace(_Args&&... __args)
254 {
return c.emplace_back(std::forward<_Args>(__args)...); }
256 template<
typename... _Args>
258 emplace(_Args&&... __args)
259 { c.emplace_back(std::forward<_Args>(__args)...); }
277 __glibcxx_requires_nonempty();
281 #if __cplusplus >= 201103L 284 #if __cplusplus > 201402L || !defined(__STRICT_ANSI__) // c++1z or gnu++11 285 noexcept(__is_nothrow_swappable<_Sequence>::value)
287 noexcept(__is_nothrow_swappable<_Tp>::value)
293 #endif // __cplusplus >= 201103L 307 template<
typename _Tp,
typename _Seq>
310 {
return __x.
c == __y.
c; }
325 template<
typename _Tp,
typename _Seq>
328 {
return __x.
c < __y.c; }
331 template<
typename _Tp,
typename _Seq>
334 {
return !(__x == __y); }
337 template<
typename _Tp,
typename _Seq>
340 {
return __y < __x; }
343 template<
typename _Tp,
typename _Seq>
346 {
return !(__y < __x); }
349 template<
typename _Tp,
typename _Seq>
352 {
return !(__x < __y); }
354 #if __cplusplus >= 201103L 355 template<
typename _Tp,
typename _Seq>
357 #if __cplusplus > 201402L || !defined(__STRICT_ANSI__) // c++1z or gnu++11 359 typename enable_if<__is_swappable<_Seq>::value>::type
364 noexcept(noexcept(__x.swap(__y)))
367 template<
typename _Tp,
typename _Seq,
typename _Alloc>
370 #endif // __cplusplus >= 201103L 412 template<
typename _Tp,
typename _Sequence = vector<_Tp>,
413 typename _Compare = less<
typename _Sequence::value_type> >
417 typedef typename _Sequence::value_type _Sequence_value_type;
418 __glibcxx_class_requires(_Tp, _SGIAssignableConcept)
419 __glibcxx_class_requires(_Sequence, _SequenceConcept)
420 __glibcxx_class_requires(_Sequence, _RandomAccessContainerConcept)
421 __glibcxx_class_requires2(_Tp, _Sequence_value_type, _SameTypeConcept)
422 __glibcxx_class_requires4(_Compare,
bool, _Tp, _Tp,
423 _BinaryFunctionConcept)
425 #if __cplusplus >= 201103L 426 template<
typename _Alloc>
427 using _Uses =
typename 428 enable_if<uses_allocator<_Sequence, _Alloc>::value>::type;
432 typedef typename _Sequence::value_type value_type;
433 typedef typename _Sequence::reference reference;
434 typedef typename _Sequence::const_reference const_reference;
435 typedef typename _Sequence::size_type size_type;
436 typedef _Sequence container_type;
439 typedef _Compare value_compare;
450 #if __cplusplus < 201103L 453 const _Sequence& __s = _Sequence())
459 const _Sequence& __s)
465 _Sequence&& __s = _Sequence())
466 :
c(std::move(__s)), comp(__x)
469 template<
typename _Alloc,
typename _Requires = _Uses<_Alloc>>
471 priority_queue(
const _Alloc& __a)
474 template<
typename _Alloc,
typename _Requires = _Uses<_Alloc>>
475 priority_queue(
const _Compare& __x,
const _Alloc& __a)
476 :
c(__a), comp(__x) { }
478 template<
typename _Alloc,
typename _Requires = _Uses<_Alloc>>
479 priority_queue(
const _Compare& __x,
const _Sequence& __c,
481 :
c(__c, __a), comp(__x) { }
483 template<
typename _Alloc,
typename _Requires = _Uses<_Alloc>>
484 priority_queue(
const _Compare& __x, _Sequence&& __c,
const _Alloc& __a)
485 :
c(std::move(__c), __a), comp(__x) { }
487 template<
typename _Alloc,
typename _Requires = _Uses<_Alloc>>
488 priority_queue(
const priority_queue& __q,
const _Alloc& __a)
489 :
c(__q.c, __a), comp(__q.comp) { }
491 template<
typename _Alloc,
typename _Requires = _Uses<_Alloc>>
492 priority_queue(priority_queue&& __q,
const _Alloc& __a)
493 :
c(std::move(__q.c), __a), comp(std::move(__q.comp)) { }
511 #if __cplusplus < 201103L 512 template<
typename _InputIterator>
513 priority_queue(_InputIterator __first, _InputIterator __last,
514 const _Compare& __x = _Compare(),
515 const _Sequence& __s = _Sequence())
518 __glibcxx_requires_valid_range(__first, __last);
519 c.insert(c.end(), __first, __last);
523 template<
typename _InputIterator>
526 const _Sequence& __s)
529 __glibcxx_requires_valid_range(__first, __last);
530 c.insert(c.end(), __first, __last);
534 template<
typename _InputIterator>
535 priority_queue(_InputIterator __first, _InputIterator __last,
536 const _Compare& __x = _Compare(),
537 _Sequence&& __s = _Sequence())
538 :
c(std::move(__s)), comp(__x)
540 __glibcxx_requires_valid_range(__first, __last);
541 c.insert(c.end(), __first, __last);
551 {
return c.empty(); }
565 __glibcxx_requires_nonempty();
584 #if __cplusplus >= 201103L 586 push(value_type&& __x)
588 c.push_back(std::move(__x));
592 template<
typename... _Args>
594 emplace(_Args&&... __args)
596 c.emplace_back(std::forward<_Args>(__args)...);
615 __glibcxx_requires_nonempty();
620 #if __cplusplus >= 201103L 622 swap(priority_queue& __pq)
624 #
if __cplusplus > 201402L || !defined(__STRICT_ANSI__)
625 __is_nothrow_swappable<_Sequence>,
627 __is_nothrow_swappable<_Tp>,
629 __is_nothrow_swappable<_Compare>
634 swap(comp, __pq.comp);
636 #endif // __cplusplus >= 201103L 641 #if __cplusplus >= 201103L 642 template<
typename _Tp,
typename _Sequence,
typename _Compare>
644 #if __cplusplus > 201402L || !defined(__STRICT_ANSI__) // c++1z or gnu++11 646 typename enable_if<__and_<__is_swappable<_Sequence>,
647 __is_swappable<_Compare>>::value>::type
653 noexcept(noexcept(__x.swap(__y)))
656 template<
typename _Tp,
typename _Sequence,
typename _Compare,
658 struct uses_allocator<priority_queue<_Tp, _Sequence, _Compare>, _Alloc>
660 #endif // __cplusplus >= 201103L 662 _GLIBCXX_END_NAMESPACE_VERSION
void pop()
Removes first element.
const_reference top() const
void make_heap(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp)
Construct a heap over a range using comparison functor.
priority_queue(const _Compare &__x, const _Sequence &__s)
Default constructor creates no elements.
queue(const _Sequence &__c)
Default constructor creates no elements.
void push_heap(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp)
Push an element onto a heap using comparison functor.
const_reference back() const
ISO C++ entities toplevel namespace is std.
void push(const value_type &__x)
Add data to the end of the queue.
void push(const value_type &__x)
Add data to the queue.
void pop()
Removes first element.
priority_queue(_InputIterator __first, _InputIterator __last, const _Compare &__x, const _Sequence &__s)
Builds a queue from a range.
void pop_heap(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp)
Pop an element off a heap using comparison functor.
A standard container giving FIFO behavior.
Declare uses_allocator so it can be specialized in <queue> etc.
const_reference front() const
A standard container automatically sorting its contents.