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___CXX03_QUEUE 11#define _LIBCPP___CXX03_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#include <__cxx03/__algorithm/make_heap.h> 258#include <__cxx03/__algorithm/pop_heap.h> 259#include <__cxx03/__algorithm/push_heap.h> 260#include <__cxx03/__config> 261#include <__cxx03/__functional/operations.h> 262#include <__cxx03/__fwd/deque.h> 263#include <__cxx03/__fwd/queue.h> 264#include <__cxx03/__iterator/back_insert_iterator.h> 265#include <__cxx03/__iterator/iterator_traits.h> 266#include <__cxx03/__memory/uses_allocator.h> 267#include <__cxx03/__utility/forward.h> 268#include <__cxx03/deque> 269#include <__cxx03/vector> 270#include <__cxx03/version> 271 272#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) 273# pragma GCC system_header 274#endif 275 276_LIBCPP_PUSH_MACROS 277#include <__cxx03/__undef_macros> 278 279_LIBCPP_BEGIN_NAMESPACE_STD 280 281template <class _Tp, class _Container> 282_LIBCPP_HIDE_FROM_ABI bool operator==(const queue<_Tp, _Container>& __x, const queue<_Tp, _Container>& __y); 283 284template <class _Tp, class _Container> 285_LIBCPP_HIDE_FROM_ABI bool operator<(const queue<_Tp, _Container>& __x, const queue<_Tp, _Container>& __y); 286 287template <class _Tp, class _Container /*= deque<_Tp>*/> 288class _LIBCPP_TEMPLATE_VIS queue { 289public: 290 typedef _Container container_type; 291 typedef typename container_type::value_type value_type; 292 typedef typename container_type::reference reference; 293 typedef typename container_type::const_reference const_reference; 294 typedef typename container_type::size_type size_type; 295 static_assert(is_same<_Tp, value_type>::value, ""); 296 297protected: 298 container_type c; 299 300public: 301 _LIBCPP_HIDE_FROM_ABI queue() : c() {} 302 303 _LIBCPP_HIDE_FROM_ABI queue(const queue& __q) : c(__q.c) {} 304 305 _LIBCPP_HIDE_FROM_ABI queue& operator=(const queue& __q) { 306 c = __q.c; 307 return *this; 308 } 309 310 _LIBCPP_HIDE_FROM_ABI explicit queue(const container_type& __c) : c(__c) {} 311 312 template <class _Alloc, __enable_if_t<uses_allocator<container_type, _Alloc>::value, int> = 0> 313 _LIBCPP_HIDE_FROM_ABI explicit queue(const _Alloc& __a) : c(__a) {} 314 315 template <class _Alloc, __enable_if_t<uses_allocator<container_type, _Alloc>::value, int> = 0> 316 _LIBCPP_HIDE_FROM_ABI queue(const queue& __q, const _Alloc& __a) : c(__q.c, __a) {} 317 318 template <class _Alloc, __enable_if_t<uses_allocator<container_type, _Alloc>::value, int> = 0> 319 _LIBCPP_HIDE_FROM_ABI queue(const container_type& __c, const _Alloc& __a) : c(__c, __a) {} 320 321 _LIBCPP_NODISCARD _LIBCPP_HIDE_FROM_ABI bool empty() const { return c.empty(); } 322 _LIBCPP_HIDE_FROM_ABI size_type size() const { return c.size(); } 323 324 _LIBCPP_HIDE_FROM_ABI reference front() { return c.front(); } 325 _LIBCPP_HIDE_FROM_ABI const_reference front() const { return c.front(); } 326 _LIBCPP_HIDE_FROM_ABI reference back() { return c.back(); } 327 _LIBCPP_HIDE_FROM_ABI const_reference back() const { return c.back(); } 328 329 _LIBCPP_HIDE_FROM_ABI void push(const value_type& __v) { c.push_back(__v); } 330 _LIBCPP_HIDE_FROM_ABI void pop() { c.pop_front(); } 331 332 _LIBCPP_HIDE_FROM_ABI void swap(queue& __q) { 333 using std::swap; 334 swap(c, __q.c); 335 } 336 337 _LIBCPP_NODISCARD _LIBCPP_HIDE_FROM_ABI const _Container& __get_container() const { return c; } 338 339 template <class _T1, class _OtherContainer> 340 friend _LIBCPP_HIDE_FROM_ABI bool 341 operator==(const queue<_T1, _OtherContainer>& __x, const queue<_T1, _OtherContainer>& __y); 342 343 template <class _T1, class _OtherContainer> 344 friend _LIBCPP_HIDE_FROM_ABI bool 345 operator<(const queue<_T1, _OtherContainer>& __x, const queue<_T1, _OtherContainer>& __y); 346}; 347 348template <class _Tp, class _Container> 349inline _LIBCPP_HIDE_FROM_ABI bool operator==(const queue<_Tp, _Container>& __x, const queue<_Tp, _Container>& __y) { 350 return __x.c == __y.c; 351} 352 353template <class _Tp, class _Container> 354inline _LIBCPP_HIDE_FROM_ABI bool operator<(const queue<_Tp, _Container>& __x, const queue<_Tp, _Container>& __y) { 355 return __x.c < __y.c; 356} 357 358template <class _Tp, class _Container> 359inline _LIBCPP_HIDE_FROM_ABI bool operator!=(const queue<_Tp, _Container>& __x, const queue<_Tp, _Container>& __y) { 360 return !(__x == __y); 361} 362 363template <class _Tp, class _Container> 364inline _LIBCPP_HIDE_FROM_ABI bool operator>(const queue<_Tp, _Container>& __x, const queue<_Tp, _Container>& __y) { 365 return __y < __x; 366} 367 368template <class _Tp, class _Container> 369inline _LIBCPP_HIDE_FROM_ABI bool operator>=(const queue<_Tp, _Container>& __x, const queue<_Tp, _Container>& __y) { 370 return !(__x < __y); 371} 372 373template <class _Tp, class _Container> 374inline _LIBCPP_HIDE_FROM_ABI bool operator<=(const queue<_Tp, _Container>& __x, const queue<_Tp, _Container>& __y) { 375 return !(__y < __x); 376} 377 378template <class _Tp, class _Container, __enable_if_t<__is_swappable_v<_Container>, int> = 0> 379inline _LIBCPP_HIDE_FROM_ABI void swap(queue<_Tp, _Container>& __x, queue<_Tp, _Container>& __y) { 380 __x.swap(__y); 381} 382 383template <class _Tp, class _Container, class _Alloc> 384struct _LIBCPP_TEMPLATE_VIS uses_allocator<queue<_Tp, _Container>, _Alloc> : public uses_allocator<_Container, _Alloc> { 385}; 386 387template <class _Tp, class _Container, class _Compare> 388class _LIBCPP_TEMPLATE_VIS priority_queue { 389public: 390 typedef _Container container_type; 391 typedef _Compare value_compare; 392 typedef typename container_type::value_type value_type; 393 typedef typename container_type::reference reference; 394 typedef typename container_type::const_reference const_reference; 395 typedef typename container_type::size_type size_type; 396 static_assert(is_same<_Tp, value_type>::value, ""); 397 398protected: 399 container_type c; 400 value_compare comp; 401 402public: 403 _LIBCPP_HIDE_FROM_ABI priority_queue() : c(), comp() {} 404 405 _LIBCPP_HIDE_FROM_ABI priority_queue(const priority_queue& __q) : c(__q.c), comp(__q.comp) {} 406 407 _LIBCPP_HIDE_FROM_ABI priority_queue& operator=(const priority_queue& __q) { 408 c = __q.c; 409 comp = __q.comp; 410 return *this; 411 } 412 413 _LIBCPP_HIDE_FROM_ABI explicit priority_queue(const value_compare& __comp) : c(), comp(__comp) {} 414 _LIBCPP_HIDE_FROM_ABI priority_queue(const value_compare& __comp, const container_type& __c); 415 template <class _InputIter, __enable_if_t<__has_input_iterator_category<_InputIter>::value, int> = 0> 416 _LIBCPP_HIDE_FROM_ABI priority_queue(_InputIter __f, _InputIter __l, const value_compare& __comp = value_compare()); 417 418 template <class _InputIter, __enable_if_t<__has_input_iterator_category<_InputIter>::value, int> = 0> 419 _LIBCPP_HIDE_FROM_ABI 420 priority_queue(_InputIter __f, _InputIter __l, const value_compare& __comp, const container_type& __c); 421 422 template <class _Alloc, __enable_if_t<uses_allocator<container_type, _Alloc>::value, int> = 0> 423 _LIBCPP_HIDE_FROM_ABI explicit priority_queue(const _Alloc& __a); 424 425 template <class _Alloc, __enable_if_t<uses_allocator<container_type, _Alloc>::value, int> = 0> 426 _LIBCPP_HIDE_FROM_ABI priority_queue(const value_compare& __comp, const _Alloc& __a); 427 428 template <class _Alloc, __enable_if_t<uses_allocator<container_type, _Alloc>::value, int> = 0> 429 _LIBCPP_HIDE_FROM_ABI priority_queue(const value_compare& __comp, const container_type& __c, const _Alloc& __a); 430 431 template <class _Alloc, __enable_if_t<uses_allocator<container_type, _Alloc>::value, int> = 0> 432 _LIBCPP_HIDE_FROM_ABI priority_queue(const priority_queue& __q, const _Alloc& __a); 433 434 template < 435 class _InputIter, 436 class _Alloc, 437 __enable_if_t<__has_input_iterator_category<_InputIter>::value && uses_allocator<container_type, _Alloc>::value, 438 int> = 0> 439 _LIBCPP_HIDE_FROM_ABI priority_queue(_InputIter __f, _InputIter __l, const _Alloc& __a); 440 441 template < 442 class _InputIter, 443 class _Alloc, 444 __enable_if_t<__has_input_iterator_category<_InputIter>::value && uses_allocator<container_type, _Alloc>::value, 445 int> = 0> 446 _LIBCPP_HIDE_FROM_ABI priority_queue(_InputIter __f, _InputIter __l, const value_compare& __comp, const _Alloc& __a); 447 448 template < 449 class _InputIter, 450 class _Alloc, 451 __enable_if_t<__has_input_iterator_category<_InputIter>::value && uses_allocator<container_type, _Alloc>::value, 452 int> = 0> 453 _LIBCPP_HIDE_FROM_ABI priority_queue( 454 _InputIter __f, _InputIter __l, const value_compare& __comp, const container_type& __c, const _Alloc& __a); 455 456 _LIBCPP_NODISCARD _LIBCPP_HIDE_FROM_ABI bool empty() const { return c.empty(); } 457 _LIBCPP_HIDE_FROM_ABI size_type size() const { return c.size(); } 458 _LIBCPP_HIDE_FROM_ABI const_reference top() const { return c.front(); } 459 460 _LIBCPP_HIDE_FROM_ABI void push(const value_type& __v); 461 _LIBCPP_HIDE_FROM_ABI void pop(); 462 463 _LIBCPP_HIDE_FROM_ABI void swap(priority_queue& __q); 464 465 _LIBCPP_NODISCARD _LIBCPP_HIDE_FROM_ABI const _Container& __get_container() const { return c; } 466}; 467 468template <class _Tp, class _Container, class _Compare> 469inline priority_queue<_Tp, _Container, _Compare>::priority_queue(const _Compare& __comp, const container_type& __c) 470 : c(__c), comp(__comp) { 471 std::make_heap(c.begin(), c.end(), comp); 472} 473 474template <class _Tp, class _Container, class _Compare> 475template <class _InputIter, __enable_if_t<__has_input_iterator_category<_InputIter>::value, int> > 476inline priority_queue<_Tp, _Container, _Compare>::priority_queue( 477 _InputIter __f, _InputIter __l, const value_compare& __comp) 478 : c(__f, __l), comp(__comp) { 479 std::make_heap(c.begin(), c.end(), comp); 480} 481 482template <class _Tp, class _Container, class _Compare> 483template <class _InputIter, __enable_if_t<__has_input_iterator_category<_InputIter>::value, int> > 484inline priority_queue<_Tp, _Container, _Compare>::priority_queue( 485 _InputIter __f, _InputIter __l, const value_compare& __comp, const container_type& __c) 486 : c(__c), comp(__comp) { 487 c.insert(c.end(), __f, __l); 488 std::make_heap(c.begin(), c.end(), comp); 489} 490 491template <class _Tp, class _Container, class _Compare> 492template <class _Alloc, __enable_if_t<uses_allocator<_Container, _Alloc>::value, int> > 493inline priority_queue<_Tp, _Container, _Compare>::priority_queue(const _Alloc& __a) : c(__a) {} 494 495template <class _Tp, class _Container, class _Compare> 496template <class _Alloc, __enable_if_t<uses_allocator<_Container, _Alloc>::value, int> > 497inline priority_queue<_Tp, _Container, _Compare>::priority_queue(const value_compare& __comp, const _Alloc& __a) 498 : c(__a), comp(__comp) {} 499 500template <class _Tp, class _Container, class _Compare> 501template <class _Alloc, __enable_if_t<uses_allocator<_Container, _Alloc>::value, int> > 502inline priority_queue<_Tp, _Container, _Compare>::priority_queue( 503 const value_compare& __comp, const container_type& __c, const _Alloc& __a) 504 : c(__c, __a), comp(__comp) { 505 std::make_heap(c.begin(), c.end(), comp); 506} 507 508template <class _Tp, class _Container, class _Compare> 509template <class _Alloc, __enable_if_t<uses_allocator<_Container, _Alloc>::value, int> > 510inline priority_queue<_Tp, _Container, _Compare>::priority_queue(const priority_queue& __q, const _Alloc& __a) 511 : c(__q.c, __a), comp(__q.comp) {} 512 513template <class _Tp, class _Container, class _Compare> 514template < 515 class _InputIter, 516 class _Alloc, 517 __enable_if_t<__has_input_iterator_category<_InputIter>::value && uses_allocator<_Container, _Alloc>::value, int> > 518inline priority_queue<_Tp, _Container, _Compare>::priority_queue(_InputIter __f, _InputIter __l, const _Alloc& __a) 519 : c(__f, __l, __a), comp() { 520 std::make_heap(c.begin(), c.end(), comp); 521} 522 523template <class _Tp, class _Container, class _Compare> 524template < 525 class _InputIter, 526 class _Alloc, 527 __enable_if_t<__has_input_iterator_category<_InputIter>::value && uses_allocator<_Container, _Alloc>::value, int> > 528inline priority_queue<_Tp, _Container, _Compare>::priority_queue( 529 _InputIter __f, _InputIter __l, const value_compare& __comp, const _Alloc& __a) 530 : c(__f, __l, __a), comp(__comp) { 531 std::make_heap(c.begin(), c.end(), comp); 532} 533 534template <class _Tp, class _Container, class _Compare> 535template < 536 class _InputIter, 537 class _Alloc, 538 __enable_if_t<__has_input_iterator_category<_InputIter>::value && uses_allocator<_Container, _Alloc>::value, int> > 539inline priority_queue<_Tp, _Container, _Compare>::priority_queue( 540 _InputIter __f, _InputIter __l, const value_compare& __comp, const container_type& __c, const _Alloc& __a) 541 : c(__c, __a), comp(__comp) { 542 c.insert(c.end(), __f, __l); 543 std::make_heap(c.begin(), c.end(), comp); 544} 545 546template <class _Tp, class _Container, class _Compare> 547inline void priority_queue<_Tp, _Container, _Compare>::push(const value_type& __v) { 548 c.push_back(__v); 549 std::push_heap(c.begin(), c.end(), comp); 550} 551 552template <class _Tp, class _Container, class _Compare> 553inline void priority_queue<_Tp, _Container, _Compare>::pop() { 554 std::pop_heap(c.begin(), c.end(), comp); 555 c.pop_back(); 556} 557 558template <class _Tp, class _Container, class _Compare> 559inline void priority_queue<_Tp, _Container, _Compare>::swap(priority_queue& __q) { 560 using std::swap; 561 swap(c, __q.c); 562 swap(comp, __q.comp); 563} 564 565template <class _Tp, 566 class _Container, 567 class _Compare, 568 __enable_if_t<__is_swappable_v<_Container> && __is_swappable_v<_Compare>, int> = 0> 569inline _LIBCPP_HIDE_FROM_ABI void 570swap(priority_queue<_Tp, _Container, _Compare>& __x, priority_queue<_Tp, _Container, _Compare>& __y) { 571 __x.swap(__y); 572} 573 574template <class _Tp, class _Container, class _Compare, class _Alloc> 575struct _LIBCPP_TEMPLATE_VIS uses_allocator<priority_queue<_Tp, _Container, _Compare>, _Alloc> 576 : public uses_allocator<_Container, _Alloc> {}; 577 578_LIBCPP_END_NAMESPACE_STD 579 580_LIBCPP_POP_MACROS 581 582#if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) 583# include <__cxx03/cstdlib> 584# include <__cxx03/functional> 585# include <__cxx03/type_traits> 586#endif 587 588#endif // _LIBCPP___CXX03_QUEUE 589