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 
00061 #ifndef __GLIBCPP_INTERNAL_QUEUE_H
00062 #define __GLIBCPP_INTERNAL_QUEUE_H
00063 
00064 #include <bits/concept_check.h>
00065 
00066 namespace std
00067 {
00068 
00069 
00070 
00071 template <class _Tp, 
00072           class _Sequence = deque<_Tp> >
00073 class queue;
00074 
00075 template <class _Tp, class _Seq>
00076 inline bool operator==(const queue<_Tp, _Seq>&, const queue<_Tp, _Seq>&);
00077 
00078 template <class _Tp, class _Seq>
00079 inline bool operator<(const queue<_Tp, _Seq>&, const queue<_Tp, _Seq>&);
00080 
00081 
00082 template <class _Tp, class _Sequence>
00083 class queue
00084 {
00085   
00086   __glibcpp_class_requires(_Tp, _SGIAssignableConcept)
00087   __glibcpp_class_requires(_Sequence, _FrontInsertionSequenceConcept)
00088   __glibcpp_class_requires(_Sequence, _BackInsertionSequenceConcept)
00089   typedef typename _Sequence::value_type _Sequence_value_type;
00090   __glibcpp_class_requires2(_Tp, _Sequence_value_type, _SameTypeConcept);
00091 
00092   template <class _Tp1, class _Seq1>
00093   friend bool operator== (const queue<_Tp1, _Seq1>&,
00094                           const queue<_Tp1, _Seq1>&);
00095   template <class _Tp1, class _Seq1>
00096   friend bool operator< (const queue<_Tp1, _Seq1>&,
00097                          const queue<_Tp1, _Seq1>&);
00098 public:
00099   typedef typename _Sequence::value_type      value_type;
00100   typedef typename _Sequence::size_type       size_type;
00101   typedef          _Sequence                  container_type;
00102 
00103   typedef typename _Sequence::reference       reference;
00104   typedef typename _Sequence::const_reference const_reference;
00105 protected:
00106   _Sequence c;
00107 public:
00108   explicit queue(const _Sequence& __c = _Sequence()) : c(__c) {}
00109 
00110   bool empty() const { return c.empty(); }
00111   size_type size() const { return c.size(); }
00112   reference front() { return c.front(); }
00113   const_reference front() const { return c.front(); }
00114   reference back() { return c.back(); }
00115   const_reference back() const { return c.back(); }
00116   void push(const value_type& __x) { c.push_back(__x); }
00117   void pop() { c.pop_front(); }
00118 };
00119 
00120 template <class _Tp, class _Sequence>
00121 bool 
00122 operator==(const queue<_Tp, _Sequence>& __x, const queue<_Tp, _Sequence>& __y)
00123 {
00124   return __x.c == __y.c;
00125 }
00126 
00127 template <class _Tp, class _Sequence>
00128 bool
00129 operator<(const queue<_Tp, _Sequence>& __x, const queue<_Tp, _Sequence>& __y)
00130 {
00131   return __x.c < __y.c;
00132 }
00133 
00134 template <class _Tp, class _Sequence>
00135 bool
00136 operator!=(const queue<_Tp, _Sequence>& __x, const queue<_Tp, _Sequence>& __y)
00137 {
00138   return !(__x == __y);
00139 }
00140 
00141 template <class _Tp, class _Sequence>
00142 bool 
00143 operator>(const queue<_Tp, _Sequence>& __x, const queue<_Tp, _Sequence>& __y)
00144 {
00145   return __y < __x;
00146 }
00147 
00148 template <class _Tp, class _Sequence>
00149 bool 
00150 operator<=(const queue<_Tp, _Sequence>& __x, const queue<_Tp, _Sequence>& __y)
00151 {
00152   return !(__y < __x);
00153 }
00154 
00155 template <class _Tp, class _Sequence>
00156 bool 
00157 operator>=(const queue<_Tp, _Sequence>& __x, const queue<_Tp, _Sequence>& __y)
00158 {
00159   return !(__x < __y);
00160 }
00161 
00162 template <class _Tp, 
00163           class _Sequence = vector<_Tp>,
00164           class _Compare  = less<typename _Sequence::value_type> >
00165 class priority_queue
00166 {
00167   
00168   __glibcpp_class_requires(_Tp, _SGIAssignableConcept)
00169   __glibcpp_class_requires(_Sequence, _SequenceConcept)
00170   __glibcpp_class_requires(_Sequence, _RandomAccessContainerConcept)
00171   typedef typename _Sequence::value_type _Sequence_value_type;
00172   __glibcpp_class_requires2(_Tp, _Sequence_value_type, _SameTypeConcept);
00173   __glibcpp_class_requires4(_Compare, bool, _Tp, _Tp, _BinaryFunctionConcept);
00174 
00175 public:
00176   typedef typename _Sequence::value_type      value_type;
00177   typedef typename _Sequence::size_type       size_type;
00178   typedef          _Sequence                  container_type;
00179 
00180   typedef typename _Sequence::reference       reference;
00181   typedef typename _Sequence::const_reference const_reference;
00182 protected:
00183   _Sequence c;
00184   _Compare comp;
00185 public:
00186   explicit priority_queue(const _Compare& __x = _Compare(),
00187               const _Sequence& __s = _Sequence()) 
00188     : c(__s), comp(__x) 
00189     { make_heap(c.begin(), c.end(), comp); }
00190 
00191   template <class _InputIterator>
00192   priority_queue(_InputIterator __first, _InputIterator __last,
00193                  const _Compare& __x = _Compare(),
00194          const _Sequence& __s = _Sequence())
00195   : c(__s), comp(__x)
00196   { 
00197     c.insert(c.end(), __first, __last);
00198     make_heap(c.begin(), c.end(), comp);
00199   }
00200 
00201   bool empty() const { return c.empty(); }
00202   size_type size() const { return c.size(); }
00203   const_reference top() const { return c.front(); }
00204 
00205   void 
00206   push(const value_type& __x) 
00207   {
00208     try 
00209       {
00210     c.push_back(__x); 
00211     push_heap(c.begin(), c.end(), comp);
00212       }
00213     catch(...)
00214       {
00215     c.clear();
00216     __throw_exception_again; 
00217       }
00218   }
00219 
00220   void 
00221   pop() 
00222   {
00223     try 
00224       {
00225     pop_heap(c.begin(), c.end(), comp);
00226     c.pop_back();
00227       }
00228     catch(...)
00229       {
00230     c.clear();
00231     __throw_exception_again; 
00232       }
00233   }
00234 };
00235 
00236 
00237 
00238 } 
00239 
00240 #endif 
00241 
00242 
00243 
00244