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 _STACK_H
00062 #define _STACK_H 1
00063
00064 #include <bits/concept_check.h>
00065 #include <debug/debug.h>
00066
00067 namespace std
00068 {
00069
00070
00071 template<typename _Tp, typename _Sequence = deque<_Tp> >
00072 class stack;
00073
00074 template<typename _Tp, typename _Seq>
00075 inline bool
00076 operator==(const stack<_Tp,_Seq>& __x, const stack<_Tp,_Seq>& __y);
00077
00078 template<typename _Tp, typename _Seq>
00079 inline bool
00080 operator<(const stack<_Tp,_Seq>& __x, const stack<_Tp,_Seq>& __y);
00081
00109 template<typename _Tp, typename _Sequence>
00110 class stack
00111 {
00112
00113 typedef typename _Sequence::value_type _Sequence_value_type;
00114 __glibcxx_class_requires(_Tp, _SGIAssignableConcept)
00115 __glibcxx_class_requires(_Sequence, _BackInsertionSequenceConcept)
00116 __glibcxx_class_requires2(_Tp, _Sequence_value_type, _SameTypeConcept)
00117
00118 template<typename _Tp1, typename _Seq1>
00119 friend bool
00120 operator==(const stack<_Tp1, _Seq1>&, const stack<_Tp1, _Seq1>&);
00121
00122 template<typename _Tp1, typename _Seq1>
00123 friend bool
00124 operator<(const stack<_Tp1, _Seq1>&, const stack<_Tp1, _Seq1>&);
00125
00126 public:
00127 typedef typename _Sequence::value_type value_type;
00128 typedef typename _Sequence::reference reference;
00129 typedef typename _Sequence::const_reference const_reference;
00130 typedef typename _Sequence::size_type size_type;
00131 typedef _Sequence container_type;
00132
00133 protected:
00134
00135 _Sequence c;
00136
00137 public:
00138
00142 explicit
00143 stack(const _Sequence& __c = _Sequence())
00144 : c(__c) {}
00145
00149 bool
00150 empty() const
00151 { return c.empty(); }
00152
00154 size_type
00155 size() const
00156 { return c.size(); }
00157
00162 reference
00163 top()
00164 {
00165 __glibcxx_requires_nonempty();
00166 return c.back();
00167 }
00168
00173 const_reference
00174 top() const
00175 {
00176 __glibcxx_requires_nonempty();
00177 return c.back();
00178 }
00179
00189 void
00190 push(const value_type& __x)
00191 { c.push_back(__x); }
00192
00204 void
00205 pop()
00206 {
00207 __glibcxx_requires_nonempty();
00208 c.pop_back();
00209 }
00210 };
00211
00224 template<typename _Tp, typename _Seq>
00225 inline bool
00226 operator==(const stack<_Tp, _Seq>& __x, const stack<_Tp, _Seq>& __y)
00227 { return __x.c == __y.c; }
00228
00242 template<typename _Tp, typename _Seq>
00243 inline bool
00244 operator<(const stack<_Tp, _Seq>& __x, const stack<_Tp, _Seq>& __y)
00245 { return __x.c < __y.c; }
00246
00248 template<typename _Tp, typename _Seq>
00249 inline bool
00250 operator!=(const stack<_Tp, _Seq>& __x, const stack<_Tp, _Seq>& __y)
00251 { return !(__x == __y); }
00252
00254 template<typename _Tp, typename _Seq>
00255 inline bool
00256 operator>(const stack<_Tp, _Seq>& __x, const stack<_Tp, _Seq>& __y)
00257 { return __y < __x; }
00258
00260 template<typename _Tp, typename _Seq>
00261 inline bool
00262 operator<=(const stack<_Tp, _Seq>& __x, const stack<_Tp, _Seq>& __y)
00263 { return !(__y < __x); }
00264
00266 template<typename _Tp, typename _Seq>
00267 inline bool
00268 operator>=(const stack<_Tp, _Seq>& __x, const stack<_Tp, _Seq>& __y)
00269 { return !(__x < __y); }
00270 }
00271
00272 #endif