Modified code to remove compiler warnings.
[dyninst.git] / common / h / Vector.h
1 /************************************************************************
2  * Vector.h: resizable vectors.
3 ************************************************************************/
4
5
6 \f
7
8
9 #if !defined(_Vector_h_)
10 #define _Vector_h_
11
12 #if defined(external_templates)
13 #pragma interface
14 #endif
15
16 \f
17
18 /************************************************************************
19  * header files.
20 ************************************************************************/
21
22 #include <assert.h>
23 #include <stdlib.h>
24
25
26 \f
27
28 /************************************************************************
29  * template<class T> class Vector
30 ************************************************************************/
31
32 #if !defined(DO_INLINE_P)
33 #define DO_INLINE_P
34 #endif
35
36 #if !defined(DO_INLINE_F)
37 #define DO_INLINE_F
38 #endif
39
40 template<class T>
41 class vector {
42 public:
43     DO_INLINE_F vector (unsigned =0);
44     DO_INLINE_F vector (unsigned, const T &);
45     DO_INLINE_F vector (const vector<T> &);
46     DO_INLINE_F ~vector ();
47
48     DO_INLINE_F vector<T>&  operator= (const vector<T> &);
49     DO_INLINE_F vector<T>&  operator= (const T &);
50     DO_INLINE_F vector<T>& operator+= (const vector<T> &);
51     DO_INLINE_F vector<T>& operator+= (const T &);
52     DO_INLINE_F vector<T>   operator+ (const vector<T> &)                      const;
53     DO_INLINE_F vector<T>   operator- ()                                       const;
54
55     DO_INLINE_F T&         operator[] (unsigned)                               const;
56     DO_INLINE_F bool       operator== (const vector<T> &)                      const;
57     DO_INLINE_F unsigned         size ()                                       const;
58     DO_INLINE_F void           resize (unsigned);
59
60     DO_INLINE_F void       extract(const unsigned index);
61
62     DO_INLINE_F void             sort (int (*)(const void *, const void *));
63     DO_INLINE_F bool           sorted (int (*)(const void *, const void *))    const;
64     DO_INLINE_F void              app (void (*)(T &));
65     DO_INLINE_F void           revapp (void (*)(T &));
66     DO_INLINE_F T                fold (T (*)(const T &, const T &), const T &) const;
67     DO_INLINE_F T             revfold (T (*)(const T &, const T &), const T &) const;
68
69 private:
70     DO_INLINE_P void  create (unsigned);
71     DO_INLINE_P void    init (const T &);
72     DO_INLINE_P void    copy (unsigned, const T *);
73     DO_INLINE_P void destroy ();
74
75     T*       data_;
76     unsigned sz_;
77     unsigned tsz_;
78 };
79
80 template<class T>
81 DO_INLINE_F
82 vector<T>::vector(unsigned sz)
83     : data_(0), sz_(0), tsz_(0) {
84     create(sz);
85 }
86
87 template<class T>
88 DO_INLINE_F
89 vector<T>::vector(unsigned sz, const T& v0)
90     : data_(0), sz_(0), tsz_(0) {
91     create(sz);
92     init(v0);
93 }
94
95
96 template<class T>
97 DO_INLINE_F
98 vector<T>::vector(const vector<T>& v)
99     : data_(0), sz_(0), tsz_(0) {
100     create(v.sz_);
101     copy(v.sz_, v.data_);
102 }
103
104 template<class T>
105 DO_INLINE_F
106 vector<T>::~vector() {
107     destroy();
108 }
109
110 template<class T>
111 DO_INLINE_F
112 vector<T>&
113 vector<T>::operator=(const vector<T>& v) {
114     if (this == &v) {
115         return *this;
116     }
117     destroy();
118     create(v.sz_);
119     copy(v.sz_, v.data_);
120     return *this;
121 }
122
123 template<class T>
124 DO_INLINE_F
125 vector<T>&
126 vector<T>::operator=(const T& v0) {
127     init(v0);
128     return *this;
129 }
130
131 template<class T>
132 DO_INLINE_F
133 vector<T>&
134 vector<T>::operator+=(const vector<T>& v) {
135     unsigned osz = sz_;
136     resize(osz + v.sz_);
137     for (unsigned i = osz; i < sz_; ++i) {
138         data_[i] = v.data_[i-osz];
139     }
140     return *this;
141 }
142
143 template<class T>
144 DO_INLINE_F
145 vector<T>&
146 vector<T>::operator+=(const T& v0) {
147     resize(sz_+1);
148     data_[sz_-1] = v0;
149     return *this;
150 }
151
152 template<class T>
153 DO_INLINE_F
154 vector<T>
155 vector<T>::operator+(const vector<T>& v) const {
156     vector<T> ret = *this;
157     return ret += v;
158 }
159
160 template<class T>
161 DO_INLINE_F
162 vector<T>
163 vector<T>::operator-() const {
164     vector<T> ret(sz_);
165     for (unsigned i = 0; i < sz_; ++i) {
166         ret.data_[sz_-i-1] = data_[i];
167     }
168     return ret;
169 }
170
171 template<class T>
172 DO_INLINE_F
173 T&
174 vector<T>::operator[](unsigned i) const {
175     assert(i < sz_);
176     return data_[i];
177 }
178
179 template<class T>
180 DO_INLINE_F
181 bool
182 vector<T>::operator==(const vector<T>& v) const {
183     if (sz_ != v.sz_) {
184         return false;
185     }
186 // TODO
187 #if defined(notdef)
188     for (unsigned i = 0; i < sz_; i++) {
189         if (!(data_[i] == v.data_[i])) {
190             return false;
191         }
192     }
193 #endif
194     return true;
195 }
196
197 template<class T>
198 DO_INLINE_F
199 unsigned
200 vector<T>::size() const {
201     return sz_;
202 }
203
204 template<class T>
205 DO_INLINE_F
206 void
207 vector<T>::resize(unsigned sz) {
208     if (tsz_ == 0) {
209         create(sz);
210     }
211     else if (tsz_ >= sz) {
212         sz_ = sz;
213     }
214     else {
215         T*       odata = data_;
216         unsigned osz   = sz_;
217         unsigned nsz   = (((2*tsz_)>sz)?(2*tsz_):(sz));
218
219         data_ = new T[nsz];
220         tsz_  = nsz;
221         sz_   = sz;
222
223         for (unsigned i = 0; i < osz; ++i) {
224             data_[i] = odata[i];
225         }
226         delete[] odata;
227
228         sz_ = sz;
229     }
230 }
231
232 template<class T>
233 DO_INLINE_F
234 void
235 vector<T>::extract(const unsigned index) {
236   if (index < (sz_ - 1)) {
237     data_[index] = data_[sz_ - 1];
238   } else if (index >= sz_)
239     return;
240
241   resize(sz_ - 1);
242 }
243
244 template<class T>
245 DO_INLINE_F
246 void
247 vector<T>::sort(int (*cmpfunc)(const void *, const void *)) {
248     qsort((void *) data_, sz_, sizeof(T), cmpfunc);
249 }
250
251 template<class T>
252 DO_INLINE_F
253 bool
254 vector<T>::sorted(int (*cmpfunc)(const void *, const void *)) const {
255     if (sz_ <= 1) {
256         return true;
257     }
258     for (unsigned i = 0; i < (sz_-1); ++i) {
259         if (cmpfunc(&data_[i], &data_[i+1]) > 0) {
260             return false;
261         }
262     }
263     return true;
264 }
265
266 template<class T>
267 DO_INLINE_F
268 void
269 vector<T>::app(void (*f)(T &)) {
270     for (unsigned i = 0; i < sz_; ++i) {
271         f(data_[i]);
272     }
273 }
274
275 template<class T>
276 DO_INLINE_F
277 void
278 vector<T>::revapp(void (*f)(T &)) {
279     for (int i = sz_-1; i >= 0; --i) {
280         f(data_[i]);
281     }
282 }
283
284 template<class T>
285 DO_INLINE_F
286 T
287 vector<T>::fold(T (*f)(const T &, const T &), const T& arg0) const {
288     T ret = arg0;
289     for (int i = sz_-1; i >= 0; --i) {
290         ret = f(data_[i], ret);
291     }
292     return ret;
293 }
294
295 template<class T>
296 DO_INLINE_F
297 T
298 vector<T>::revfold(T (*f)(const T &, const T &), const T& arg0) const {
299     T ret = arg0;
300     for (unsigned i = 0; i < sz_; ++i) {
301         ret = f(ret, data_[i]);
302     }
303     return ret;
304 }
305
306 template<class T>
307 DO_INLINE_P
308 void
309 vector<T>::create(unsigned sz) {
310     if (sz > 0) {
311         data_ = new T[sz];
312     }
313     sz_ = tsz_ = sz;
314 }
315
316 template<class T>
317 DO_INLINE_P
318 void
319 vector<T>::init(const T& v0) {
320     for (unsigned i = 0; i < sz_; ++i) {
321         data_[i] = v0;
322     }
323 }
324
325 template<class T>
326 DO_INLINE_P
327 void
328 vector<T>::copy(unsigned sz, const T* data) {
329     for (unsigned i = 0; i < sz; ++i) {
330         data_[i] = data[i];
331     }
332 }
333
334 template<class T>
335 DO_INLINE_P
336 void
337 vector<T>::destroy() {
338     delete[] data_; data_ = 0;
339     sz_ = tsz_ = 0;
340 }
341
342 template<class T, class U>
343 DO_INLINE_F
344 vector<U>
345 map(U (*f)(const T &), const vector<T>& v) {
346     vector<U> ret(sz_);
347     for (unsigned i = 0; i < sz_; ++i) {
348         ret[i] = f(data_[i]);
349     }
350     return ret;
351 }
352
353 template<class T, class U>
354 DO_INLINE_F
355 U
356 fold(U (*f)(const T &, const U &), const vector<T>& v, const U& arg0) {
357     U ret = arg0;
358     for (int i = sz_-1; i >= 0; --i) {
359         ret = f(data_[i], ret);
360     }
361     return ret;
362 }
363
364 template<class T, class U>
365 DO_INLINE_F
366 U
367 revfold(U (*f)(const U &, const T &), const vector<T>& v, const U& arg0) {
368     U ret = arg0;
369     for (unsigned i = 0; i < sz_; ++i) {
370         ret = f(ret, data_[i]);
371     }
372     return ret;
373 }
374
375
376 \f
377
378
379 #endif /* !defined(_Vector_h_) */