00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027
00028
00029
00030
00031
00032
00033
00034
00035
00036
00037
00038
00039
00040
00041
00042
00043
00044
00045
00046
00047
00048
00049
00050
00051
00052
00053
00054
00055
00056
00057 #ifndef _STL_QUEUE_H
00058 #define _STL_QUEUE_H 1
00059
00060 #include <bits/concept_check.h>
00061 #include <debug/debug.h>
00062
00063 _GLIBCXX_BEGIN_NAMESPACE(std)
00064
00065
00066
00067
00068
00069
00070
00071
00072
00073
00074
00075
00076
00077
00078
00079
00080
00081
00082
00083
00084
00085
00086
00087
00088 template<typename _Tp, typename _Sequence = deque<_Tp> >
00089 class queue
00090 {
00091
00092 typedef typename _Sequence::value_type _Sequence_value_type;
00093 __glibcxx_class_requires(_Tp, _SGIAssignableConcept)
00094 __glibcxx_class_requires(_Sequence, _FrontInsertionSequenceConcept)
00095 __glibcxx_class_requires(_Sequence, _BackInsertionSequenceConcept)
00096 __glibcxx_class_requires2(_Tp, _Sequence_value_type, _SameTypeConcept)
00097
00098 template<typename _Tp1, typename _Seq1>
00099 friend bool
00100 operator==(const queue<_Tp1, _Seq1>&, const queue<_Tp1, _Seq1>&);
00101
00102 template<typename _Tp1, typename _Seq1>
00103 friend bool
00104 operator<(const queue<_Tp1, _Seq1>&, const queue<_Tp1, _Seq1>&);
00105
00106 public:
00107 typedef typename _Sequence::value_type value_type;
00108 typedef typename _Sequence::reference reference;
00109 typedef typename _Sequence::const_reference const_reference;
00110 typedef typename _Sequence::size_type size_type;
00111 typedef _Sequence container_type;
00112
00113 protected:
00114
00115
00116
00117
00118
00119
00120
00121
00122 _Sequence c;
00123
00124 public:
00125
00126
00127
00128 #ifndef __GXX_EXPERIMENTAL_CXX0X__
00129 explicit
00130 queue(const _Sequence& __c = _Sequence())
00131 : c(__c) { }
00132 #else
00133 explicit
00134 queue(const _Sequence& __c)
00135 : c(__c) { }
00136
00137 explicit
00138 queue(_Sequence&& __c = _Sequence())
00139 : c(std::move(__c)) { }
00140 #endif
00141
00142
00143
00144
00145 bool
00146 empty() const
00147 { return c.empty(); }
00148
00149
00150 size_type
00151 size() const
00152 { return c.size(); }
00153
00154
00155
00156
00157
00158 reference
00159 front()
00160 {
00161 __glibcxx_requires_nonempty();
00162 return c.front();
00163 }
00164
00165
00166
00167
00168
00169 const_reference
00170 front() const
00171 {
00172 __glibcxx_requires_nonempty();
00173 return c.front();
00174 }
00175
00176
00177
00178
00179
00180 reference
00181 back()
00182 {
00183 __glibcxx_requires_nonempty();
00184 return c.back();
00185 }
00186
00187
00188
00189
00190
00191 const_reference
00192 back() const
00193 {
00194 __glibcxx_requires_nonempty();
00195 return c.back();
00196 }
00197
00198
00199
00200
00201
00202
00203
00204
00205
00206
00207 void
00208 push(const value_type& __x)
00209 { c.push_back(__x); }
00210
00211 #ifdef __GXX_EXPERIMENTAL_CXX0X__
00212 void
00213 push(value_type&& __x)
00214 { c.push_back(std::move(__x)); }
00215
00216 template<typename... _Args>
00217 void
00218 emplace(_Args&&... __args)
00219 { c.emplace_back(std::forward<_Args>(__args)...); }
00220 #endif
00221
00222
00223
00224
00225
00226
00227
00228
00229
00230
00231
00232
00233 void
00234 pop()
00235 {
00236 __glibcxx_requires_nonempty();
00237 c.pop_front();
00238 }
00239
00240 #ifdef __GXX_EXPERIMENTAL_CXX0X__
00241 void
00242 swap(queue& __q)
00243 { c.swap(__q.c); }
00244 #endif
00245 };
00246
00247
00248
00249
00250
00251
00252
00253
00254
00255
00256
00257
00258 template<typename _Tp, typename _Seq>
00259 inline bool
00260 operator==(const queue<_Tp, _Seq>& __x, const queue<_Tp, _Seq>& __y)
00261 { return __x.c == __y.c; }
00262
00263
00264
00265
00266
00267
00268
00269
00270
00271
00272
00273
00274
00275
00276 template<typename _Tp, typename _Seq>
00277 inline bool
00278 operator<(const queue<_Tp, _Seq>& __x, const queue<_Tp, _Seq>& __y)
00279 { return __x.c < __y.c; }
00280
00281
00282 template<typename _Tp, typename _Seq>
00283 inline bool
00284 operator!=(const queue<_Tp, _Seq>& __x, const queue<_Tp, _Seq>& __y)
00285 { return !(__x == __y); }
00286
00287
00288 template<typename _Tp, typename _Seq>
00289 inline bool
00290 operator>(const queue<_Tp, _Seq>& __x, const queue<_Tp, _Seq>& __y)
00291 { return __y < __x; }
00292
00293
00294 template<typename _Tp, typename _Seq>
00295 inline bool
00296 operator<=(const queue<_Tp, _Seq>& __x, const queue<_Tp, _Seq>& __y)
00297 { return !(__y < __x); }
00298
00299
00300 template<typename _Tp, typename _Seq>
00301 inline bool
00302 operator>=(const queue<_Tp, _Seq>& __x, const queue<_Tp, _Seq>& __y)
00303 { return !(__x < __y); }
00304
00305 #ifdef __GXX_EXPERIMENTAL_CXX0X__
00306 template<typename _Tp, typename _Seq>
00307 inline void
00308 swap(queue<_Tp, _Seq>& __x, queue<_Tp, _Seq>& __y)
00309 { __x.swap(__y); }
00310
00311 template<typename _Tp, typename _Seq, typename _Alloc>
00312 struct uses_allocator<queue<_Tp, _Seq>, _Alloc>
00313 : public uses_allocator<_Seq, _Alloc>::type { };
00314 #endif
00315
00316
00317
00318
00319
00320
00321
00322
00323
00324
00325
00326
00327
00328
00329
00330
00331
00332
00333
00334
00335
00336
00337
00338
00339
00340
00341
00342
00343
00344
00345
00346
00347
00348
00349
00350
00351 template<typename _Tp, typename _Sequence = vector<_Tp>,
00352 typename _Compare = less<typename _Sequence::value_type> >
00353 class priority_queue
00354 {
00355
00356 typedef typename _Sequence::value_type _Sequence_value_type;
00357 __glibcxx_class_requires(_Tp, _SGIAssignableConcept)
00358 __glibcxx_class_requires(_Sequence, _SequenceConcept)
00359 __glibcxx_class_requires(_Sequence, _RandomAccessContainerConcept)
00360 __glibcxx_class_requires2(_Tp, _Sequence_value_type, _SameTypeConcept)
00361 __glibcxx_class_requires4(_Compare, bool, _Tp, _Tp,
00362 _BinaryFunctionConcept)
00363
00364 public:
00365 typedef typename _Sequence::value_type value_type;
00366 typedef typename _Sequence::reference reference;
00367 typedef typename _Sequence::const_reference const_reference;
00368 typedef typename _Sequence::size_type size_type;
00369 typedef _Sequence container_type;
00370
00371 protected:
00372
00373 _Sequence c;
00374 _Compare comp;
00375
00376 public:
00377
00378
00379
00380 #ifndef __GXX_EXPERIMENTAL_CXX0X__
00381 explicit
00382 priority_queue(const _Compare& __x = _Compare(),
00383 const _Sequence& __s = _Sequence())
00384 : c(__s), comp(__x)
00385 { std::make_heap(c.begin(), c.end(), comp); }
00386 #else
00387 explicit
00388 priority_queue(const _Compare& __x,
00389 const _Sequence& __s)
00390 : c(__s), comp(__x)
00391 { std::make_heap(c.begin(), c.end(), comp); }
00392
00393 explicit
00394 priority_queue(const _Compare& __x = _Compare(),
00395 _Sequence&& __s = _Sequence())
00396 : c(std::move(__s)), comp(__x)
00397 { std::make_heap(c.begin(), c.end(), comp); }
00398 #endif
00399
00400
00401
00402
00403
00404
00405
00406
00407
00408
00409
00410
00411
00412
00413
00414
00415 #ifndef __GXX_EXPERIMENTAL_CXX0X__
00416 template<typename _InputIterator>
00417 priority_queue(_InputIterator __first, _InputIterator __last,
00418 const _Compare& __x = _Compare(),
00419 const _Sequence& __s = _Sequence())
00420 : c(__s), comp(__x)
00421 {
00422 __glibcxx_requires_valid_range(__first, __last);
00423 c.insert(c.end(), __first, __last);
00424 std::make_heap(c.begin(), c.end(), comp);
00425 }
00426 #else
00427 template<typename _InputIterator>
00428 priority_queue(_InputIterator __first, _InputIterator __last,
00429 const _Compare& __x,
00430 const _Sequence& __s)
00431 : c(__s), comp(__x)
00432 {
00433 __glibcxx_requires_valid_range(__first, __last);
00434 c.insert(c.end(), __first, __last);
00435 std::make_heap(c.begin(), c.end(), comp);
00436 }
00437
00438 template<typename _InputIterator>
00439 priority_queue(_InputIterator __first, _InputIterator __last,
00440 const _Compare& __x = _Compare(),
00441 _Sequence&& __s = _Sequence())
00442 : c(std::move(__s)), comp(__x)
00443 {
00444 __glibcxx_requires_valid_range(__first, __last);
00445 c.insert(c.end(), __first, __last);
00446 std::make_heap(c.begin(), c.end(), comp);
00447 }
00448 #endif
00449
00450
00451
00452
00453 bool
00454 empty() const
00455 { return c.empty(); }
00456
00457
00458 size_type
00459 size() const
00460 { return c.size(); }
00461
00462
00463
00464
00465
00466 const_reference
00467 top() const
00468 {
00469 __glibcxx_requires_nonempty();
00470 return c.front();
00471 }
00472
00473
00474
00475
00476
00477
00478
00479
00480
00481 void
00482 push(const value_type& __x)
00483 {
00484 c.push_back(__x);
00485 std::push_heap(c.begin(), c.end(), comp);
00486 }
00487
00488 #ifdef __GXX_EXPERIMENTAL_CXX0X__
00489 void
00490 push(value_type&& __x)
00491 {
00492 c.push_back(std::move(__x));
00493 std::push_heap(c.begin(), c.end(), comp);
00494 }
00495
00496 template<typename... _Args>
00497 void
00498 emplace(_Args&&... __args)
00499 {
00500 c.emplace_back(std::forward<_Args>(__args)...);
00501 std::push_heap(c.begin(), c.end(), comp);
00502 }
00503 #endif
00504
00505
00506
00507
00508
00509
00510
00511
00512
00513
00514
00515
00516 void
00517 pop()
00518 {
00519 __glibcxx_requires_nonempty();
00520 std::pop_heap(c.begin(), c.end(), comp);
00521 c.pop_back();
00522 }
00523
00524 #ifdef __GXX_EXPERIMENTAL_CXX0X__
00525 void
00526 swap(priority_queue& __pq)
00527 {
00528 using std::swap;
00529 c.swap(__pq.c);
00530 swap(comp, __pq.comp);
00531 }
00532 #endif
00533 };
00534
00535
00536
00537 #ifdef __GXX_EXPERIMENTAL_CXX0X__
00538 template<typename _Tp, typename _Sequence, typename _Compare>
00539 inline void
00540 swap(priority_queue<_Tp, _Sequence, _Compare>& __x,
00541 priority_queue<_Tp, _Sequence, _Compare>& __y)
00542 { __x.swap(__y); }
00543
00544 template<typename _Tp, typename _Sequence, typename _Compare,
00545 typename _Alloc>
00546 struct uses_allocator<priority_queue<_Tp, _Sequence, _Compare>, _Alloc>
00547 : public uses_allocator<_Sequence, _Alloc>::type { };
00548 #endif
00549
00550 _GLIBCXX_END_NAMESPACE
00551
00552 #endif