use of new iterator style
[dyninst.git] / pdutil / h / Stack.h
1 /*
2  * Copyright (c) 1996 Barton P. Miller
3  * 
4  * We provide the Paradyn Parallel Performance Tools (below
5  * described as Paradyn") on an AS IS basis, and do not warrant its
6  * validity or performance.  We reserve the right to update, modify,
7  * or discontinue this software at any time.  We shall have no
8  * obligation to supply such updates or modifications or any other
9  * form of support to you.
10  * 
11  * This license is for research uses.  For such uses, there is no
12  * charge. We define "research use" to mean you may freely use it
13  * inside your organization for whatever purposes you see fit. But you
14  * may not re-distribute Paradyn or parts of Paradyn, in any form
15  * source or binary (including derivatives), electronic or otherwise,
16  * to any other organization or entity without our permission.
17  * 
18  * (for other uses, please contact us at paradyn@cs.wisc.edu)
19  * 
20  * All warranties, including without limitation, any warranty of
21  * merchantability or fitness for a particular purpose, are hereby
22  * excluded.
23  * 
24  * By your use of Paradyn, you understand and agree that we (or any
25  * other person or entity with proprietary rights in Paradyn) are
26  * under no obligation to provide either maintenance services,
27  * update services, notices of latent defects, or correction of
28  * defects for Paradyn.
29  * 
30  * Even if advised of the possibility of such damages, under no
31  * circumstances shall we (or any other person or entity with
32  * proprietary rights in the software licensed hereunder) be liable
33  * to you or any third party for direct, indirect, or consequential
34  * damages of any character regardless of type of action, including,
35  * without limitation, loss of profits, loss of use, loss of good
36  * will, or computer failure or malfunction.  You agree to indemnify
37  * us (and any other person or entity with proprietary rights in the
38  * software licensed hereunder) for any and all liability it may
39  * incur to third parties resulting from your use of Paradyn.
40  */
41
42 /************************************************************************
43  * Stack.h: implementation of vector-based stacks.
44 ************************************************************************/
45
46
47 \f
48
49
50 #if !defined(_Stack_h_)
51 #define _Stack_h_
52
53 #if defined(external_templates)
54 #pragma interface
55 #endif
56
57 \f
58
59
60 /************************************************************************
61  * header files.
62 ************************************************************************/
63
64 #include "util/h/Vector.h"
65
66
67 \f
68 #if !defined(DO_INLINE_P)
69 #define DO_INLINE_P
70 #endif
71
72 #if !defined(DO_INLINE_F)
73 #define DO_INLINE_F
74 #endif
75
76 /************************************************************************
77  * template<class T> class stack
78 ************************************************************************/
79
80 template<class T>
81 class stack {
82 public:
83     DO_INLINE_F         stack ();
84     DO_INLINE_F         stack (const stack<T> &);
85     DO_INLINE_F virtual ~stack ();
86
87     DO_INLINE_F stack<T>&  operator= (const stack<T> &);
88     DO_INLINE_F bool      operator== (const stack<T> &) const;
89     DO_INLINE_F stack<T>& operator+= (const stack<T> &);
90     DO_INLINE_F stack<T>   operator+ (const stack<T> &) const;
91     DO_INLINE_F stack<T>   operator- ()                 const;
92     DO_INLINE_F unsigned        size ()                 const;
93     DO_INLINE_F void            push (const T &);
94     DO_INLINE_F T                pop ();
95     DO_INLINE_F T&               top ()                 const;
96     DO_INLINE_F T&            bottom ()                 const;
97     DO_INLINE_F void           clear ();
98 #if defined(notdef)
99     DO_INLINE_F void           write (ostream &)        const;
100
101     DO_INLINE_F friend ostream& operator<< (ostream &, const stack<T> &);
102 #endif
103 private:
104     vector<T> data_;
105 };
106
107 template<class T>
108 DO_INLINE_F
109 stack<T>::stack()
110     : data_() {
111 }
112
113 template<class T>
114 DO_INLINE_F
115 stack<T>::stack(const stack<T>& s)
116     : data_(s.data_) {
117 }
118
119 template<class T>
120 DO_INLINE_F
121 stack<T>::~stack() {
122 }
123
124 template<class T>
125 DO_INLINE_F
126 stack<T>&
127 stack<T>::operator=(const stack<T>& s) {
128     if (this == &s) {
129         return *this;
130     }
131     data_ = s.data_;
132     return *this;
133 }
134
135 template<class T>
136 DO_INLINE_F
137 bool
138 stack<T>::operator==(const stack<T>& s) const {
139     if (this == &s) {
140         return true;
141     }
142     return (data_ == s.data_);
143 }
144
145 template<class T>
146 DO_INLINE_F
147 stack<T>&
148 stack<T>::operator+=(const stack<T>& s) {
149     data_ += s.data_;
150     return *this;
151 }
152
153 template<class T>
154 DO_INLINE_F
155 stack<T>
156 stack<T>::operator+(const stack<T>& s) const {
157     stack<T> n = *this;
158     n += s;
159     return n;
160 }
161
162 template<class T>
163 DO_INLINE_F
164 stack<T>
165 stack<T>::operator-() const {
166     stack<T> n = *this;
167     n.data_ = -n.data_;
168     return n;
169 }
170
171 template<class T>
172 DO_INLINE_F
173 unsigned
174 stack<T>::size() const {
175     return data_.size();
176 }
177
178 template<class T>
179 DO_INLINE_F
180 void
181 stack<T>::push(const T& t) {
182     data_ += t;
183 }
184
185 template<class T>
186 DO_INLINE_F
187 T
188 stack<T>::pop() {
189     unsigned sz = data_.size();
190     assert(sz != 0);
191
192     T t = data_[sz-1];
193     data_.resize(sz-1);
194     return t;
195 }
196
197 template<class T>
198 DO_INLINE_F
199 T&
200 stack<T>::top() const {
201     assert(data_.size() != 0);
202     return data_[data_.size()-1];
203 }
204
205 template<class T>
206 DO_INLINE_F
207 T&
208 stack<T>::bottom() const {
209     assert(data_.size() != 0);
210     return data_[0];
211 }
212
213 template<class T>
214 DO_INLINE_F
215 void
216 stack<T>::clear() {
217     data_.resize(0);
218 }
219 #if defined(notdef)
220 template<class T>
221 DO_INLINE_F
222 void
223 stack<T>::write(ostream& os) const {
224     (-data_).write(os);
225 }
226
227 template<class T>
228 DO_INLINE_F
229 ostream&
230 operator<<(ostream& os, const stack<T>& s) {
231     os << "[ top: "; s.write(os); return os << " :bottom ]";
232 }
233 #endif
234
235 \f
236
237
238 #endif /* !defined(_Stack_h_) */