Modified code to remove compiler warnings.
[dyninst.git] / common / h / Stack.h
1 /************************************************************************
2  * Stack.h: implementation of vector-based stacks.
3 ************************************************************************/
4
5
6 \f
7
8
9 #if !defined(_Stack_h_)
10 #define _Stack_h_
11
12 #if defined(external_templates)
13 #pragma interface
14 #endif
15
16 \f
17
18
19 /************************************************************************
20  * header files.
21 ************************************************************************/
22
23 #include "util/h/Vector.h"
24
25
26 \f
27 #if !defined(DO_INLINE_P)
28 #define DO_INLINE_P
29 #endif
30
31 #if !defined(DO_INLINE_F)
32 #define DO_INLINE_F
33 #endif
34
35 /************************************************************************
36  * template<class T> class stack
37 ************************************************************************/
38
39 template<class T>
40 class stack {
41 public:
42     DO_INLINE_F         stack ();
43     DO_INLINE_F         stack (const stack<T> &);
44     DO_INLINE_F virtual ~stack ();
45
46     DO_INLINE_F stack<T>&  operator= (const stack<T> &);
47     DO_INLINE_F bool      operator== (const stack<T> &) const;
48     DO_INLINE_F stack<T>& operator+= (const stack<T> &);
49     DO_INLINE_F stack<T>   operator+ (const stack<T> &) const;
50     DO_INLINE_F stack<T>   operator- ()                 const;
51     DO_INLINE_F unsigned        size ()                 const;
52     DO_INLINE_F void            push (const T &);
53     DO_INLINE_F T                pop ();
54     DO_INLINE_F T&               top ()                 const;
55     DO_INLINE_F T&            bottom ()                 const;
56     DO_INLINE_F void           clear ();
57 #if defined(notdef)
58     DO_INLINE_F void           write (ostream &)        const;
59
60     DO_INLINE_F friend ostream& operator<< (ostream &, const stack<T> &);
61 #endif
62 private:
63     vector<T> data_;
64 };
65
66 template<class T>
67 DO_INLINE_F
68 stack<T>::stack()
69     : data_() {
70 }
71
72 template<class T>
73 DO_INLINE_F
74 stack<T>::stack(const stack<T>& s)
75     : data_(s.data_) {
76 }
77
78 template<class T>
79 DO_INLINE_F
80 stack<T>::~stack() {
81 }
82
83 template<class T>
84 DO_INLINE_F
85 stack<T>&
86 stack<T>::operator=(const stack<T>& s) {
87     if (this == &s) {
88         return *this;
89     }
90     data_ = s.data_;
91     return *this;
92 }
93
94 template<class T>
95 DO_INLINE_F
96 bool
97 stack<T>::operator==(const stack<T>& s) const {
98     if (this == &s) {
99         return true;
100     }
101     return (data_ == s.data_);
102 }
103
104 template<class T>
105 DO_INLINE_F
106 stack<T>&
107 stack<T>::operator+=(const stack<T>& s) {
108     data_ += s.data_;
109     return *this;
110 }
111
112 template<class T>
113 DO_INLINE_F
114 stack<T>
115 stack<T>::operator+(const stack<T>& s) const {
116     stack<T> n = *this;
117     n += s;
118     return n;
119 }
120
121 template<class T>
122 DO_INLINE_F
123 stack<T>
124 stack<T>::operator-() const {
125     stack<T> n = *this;
126     n.data_ = -n.data_;
127     return n;
128 }
129
130 template<class T>
131 DO_INLINE_F
132 unsigned
133 stack<T>::size() const {
134     return data_.size();
135 }
136
137 template<class T>
138 DO_INLINE_F
139 void
140 stack<T>::push(const T& t) {
141     data_ += t;
142 }
143
144 template<class T>
145 DO_INLINE_F
146 T
147 stack<T>::pop() {
148     unsigned sz = data_.size();
149     assert(sz != 0);
150
151     T t = data_[sz-1];
152     data_.resize(sz-1);
153     return t;
154 }
155
156 template<class T>
157 DO_INLINE_F
158 T&
159 stack<T>::top() const {
160     assert(data_.size() != 0);
161     return data_[data_.size()-1];
162 }
163
164 template<class T>
165 DO_INLINE_F
166 T&
167 stack<T>::bottom() const {
168     assert(data_.size() != 0);
169     return data_[0];
170 }
171
172 template<class T>
173 DO_INLINE_F
174 void
175 stack<T>::clear() {
176     data_.resize(0);
177 }
178 #if defined(notdef)
179 template<class T>
180 DO_INLINE_F
181 void
182 stack<T>::write(ostream& os) const {
183     (-data_).write(os);
184 }
185
186 template<class T>
187 DO_INLINE_F
188 ostream&
189 operator<<(ostream& os, const stack<T>& s) {
190     os << "[ top: "; s.write(os); return os << " :bottom ]";
191 }
192 #endif
193
194 \f
195
196
197 #endif /* !defined(_Stack_h_) */