use of new iterator style
[dyninst.git] / common / h / VectorDeluxe.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  * VectorDeluxe.h: resizable vectors with some fancy methods not normally
44  *                 needed, like fold(), revfold(), app(), revapp(),
45  *                 operator-(), etc.
46 ************************************************************************/
47
48 #if !defined(_Vector_Deluxe_h_)
49 #define _Vector_Deluxe_h_
50
51 #if defined(external_templates)
52 #pragma interface
53 #endif
54
55 #include <assert.h>
56 #include <stdlib.h>
57
58 #if !defined(DO_INLINE_P)
59 #define DO_INLINE_P
60 #endif
61
62 #if !defined(DO_INLINE_F)
63 #define DO_INLINE_F
64 #endif
65
66 // I wanted to choose a class name shorter than "vector_deluxe".
67 // "vector" won't do because it clashes with the usual vector class,
68 // thus hopelessly confusing template instantiation.  "vectordlx" is the
69 // compromise. --at
70 template<class T>
71 class vectordlx {
72 public:
73     DO_INLINE_F vectordlx (unsigned =0);
74     DO_INLINE_F vectordlx (unsigned, const T &);
75     DO_INLINE_F vectordlx (const vectordlx<T> &);
76     DO_INLINE_F ~vectordlx ();
77
78     DO_INLINE_F vectordlx<T>&  operator= (const vectordlx<T> &);
79     DO_INLINE_F vectordlx<T>&  operator= (const T &);
80     DO_INLINE_F vectordlx<T>& operator+= (const vectordlx<T> &);
81     DO_INLINE_F vectordlx<T>& operator+= (const T &);
82     DO_INLINE_F vectordlx<T>   operator+ (const vectordlx<T> &)                const;
83     DO_INLINE_F vectordlx<T>   operator- ()                                    const;
84
85     DO_INLINE_F T&         operator[] (unsigned)                               const;
86     DO_INLINE_F bool       operator== (const vectordlx<T> &)                   const;
87     DO_INLINE_F unsigned         size ()                                       const;
88     DO_INLINE_F void           resize (unsigned);
89
90
91     DO_INLINE_F void             sort (int (*)(const void *, const void *));
92     DO_INLINE_F bool           sorted (int (*)(const void *, const void *))    const;
93     DO_INLINE_F void              app (void (*)(T &));
94     DO_INLINE_F void           revapp (void (*)(T &));
95     DO_INLINE_F T                fold (T (*)(const T &, const T &), const T &) const;
96     DO_INLINE_F T             revfold (T (*)(const T &, const T &), const T &) const;
97
98 private:
99     DO_INLINE_P void  create (unsigned);
100     DO_INLINE_P void    init (const T &);
101     DO_INLINE_P void    copy (unsigned, const T *);
102     DO_INLINE_P void destroy ();
103
104     T*       data_;
105     unsigned sz_;
106     unsigned tsz_;
107 };
108
109 template<class T>
110 DO_INLINE_F
111 vectordlx<T>::vectordlx(unsigned sz)
112     : data_(0), sz_(0), tsz_(0) {
113     create(sz);
114 }
115
116 template<class T>
117 DO_INLINE_F
118 vectordlx<T>::vectordlx(unsigned sz, const T& v0)
119     : data_(0), sz_(0), tsz_(0) {
120     create(sz);
121     init(v0);
122 }
123
124
125 template<class T>
126 DO_INLINE_F
127 vectordlx<T>::vectordlx(const vectordlx<T>& v)
128     : data_(0), sz_(0), tsz_(0) {
129     create(v.sz_);
130     copy(v.sz_, v.data_);
131 }
132
133 template<class T>
134 DO_INLINE_F
135 vectordlx<T>::~vectordlx() {
136     destroy();
137 }
138
139 template<class T>
140 DO_INLINE_F
141 vectordlx<T>&
142 vectordlx<T>::operator=(const vectordlx<T>& v) {
143     if (this == &v) {
144         return *this;
145     }
146     destroy();
147     create(v.sz_);
148     copy(v.sz_, v.data_);
149     return *this;
150 }
151
152 template<class T>
153 DO_INLINE_F
154 vectordlx<T>&
155 vectordlx<T>::operator=(const T& v0) {
156     init(v0);
157     return *this;
158 }
159
160 template<class T>
161 DO_INLINE_F
162 vectordlx<T>&
163 vectordlx<T>::operator+=(const vectordlx<T>& v) {
164     unsigned osz = sz_;
165     resize(osz + v.sz_);
166     for (unsigned i = osz; i < sz_; ++i) {
167         data_[i] = v.data_[i-osz];
168     }
169     return *this;
170 }
171
172 template<class T>
173 DO_INLINE_F
174 vectordlx<T>&
175 vectordlx<T>::operator+=(const T& v0) {
176     resize(sz_+1);
177     data_[sz_-1] = v0;
178     return *this;
179 }
180
181 template<class T>
182 DO_INLINE_F
183 vectordlx<T>
184 vectordlx<T>::operator+(const vectordlx<T>& v) const {
185     vectordlx<T> ret = *this;
186     return ret += v;
187 }
188
189 template<class T>
190 DO_INLINE_F
191 vectordlx<T>
192 vectordlx<T>::operator-() const {
193     vectordlx<T> ret(sz_);
194     for (unsigned i = 0; i < sz_; ++i) {
195         ret.data_[sz_-i-1] = data_[i];
196    }
197     return ret;
198 }
199
200 template<class T>
201 DO_INLINE_F
202 T&
203 vectordlx<T>::operator[](unsigned i) const {
204     assert(i < sz_);
205     return data_[i];
206 }
207
208 template<class T>
209 DO_INLINE_F
210 bool
211 vectordlx<T>::operator==(const vectordlx<T>& v) const {
212     if (sz_ != v.sz_) {
213         return false;
214     }
215 // TODO
216 #if defined(notdef)
217     for (unsigned i = 0; i < sz_; i++) {
218         if (!(data_[i] == v.data_[i])) {
219             return false;
220         }
221     }
222 #endif
223     return true;
224 }
225
226 template<class T>
227 DO_INLINE_F
228 unsigned
229 vectordlx<T>::size() const {
230     return sz_;
231 }
232
233 template<class T>
234 DO_INLINE_F
235 void
236 vectordlx<T>::resize(unsigned sz) {
237     if (tsz_ == 0) {
238         create(sz);
239     }
240     else if (tsz_ >= sz) {
241         sz_ = sz;
242     }
243     else {
244         T*       odata = data_;
245         unsigned osz   = sz_;
246         unsigned nsz   = (((2*tsz_)>sz)?(2*tsz_):(sz));
247
248         data_ = new T[nsz];
249         tsz_  = nsz;
250         sz_   = sz;
251
252         for (unsigned i = 0; i < osz; ++i) {
253             data_[i] = odata[i];
254         }
255         delete[] odata;
256
257         sz_ = sz;
258     }
259 }
260
261 template<class T>
262 DO_INLINE_F
263 void
264 vectordlx<T>::sort(int (*cmpfunc)(const void *, const void *)) {
265     qsort((void *) data_, sz_, sizeof(T), cmpfunc);
266 }
267
268 template<class T>
269 DO_INLINE_F
270 bool
271 vectordlx<T>::sorted(int (*cmpfunc)(const void *, const void *)) const {
272     if (sz_ <= 1) {
273         return true;
274     }
275     for (unsigned i = 0; i < (sz_-1); ++i) {
276         if (cmpfunc(&data_[i], &data_[i+1]) > 0) {
277             return false;
278         }
279     }
280     return true;
281 }
282
283 template<class T>
284 DO_INLINE_F
285 void
286 vectordlx<T>::app(void (*f)(T &)) {
287     for (unsigned i = 0; i < sz_; ++i) {
288         f(data_[i]);
289     }
290 }
291
292 template<class T>
293 DO_INLINE_F
294 void
295 vectordlx<T>::revapp(void (*f)(T &)) {
296     for (int i = sz_-1; i >= 0; --i) {
297         f(data_[i]);
298     }
299 }
300
301 template<class T>
302 DO_INLINE_F
303 T
304 vectordlx<T>::fold(T (*f)(const T &, const T &), const T& arg0) const {
305    T ret = arg0;
306    for (int i = sz_-1; i >= 0; --i) {
307        ret = f(data_[i], ret);
308    }
309    return ret;
310 }
311
312 template<class T>
313 DO_INLINE_F
314 T
315 vectordlx<T>::revfold(T (*f)(const T &, const T &), const T& arg0) const {
316   T ret = arg0;
317     for (unsigned i = 0; i < sz_; ++i) {
318         ret = f(ret, data_[i]);
319     }
320     return ret;
321 }
322
323 template<class T>
324 DO_INLINE_P
325 void
326 vectordlx<T>::create(unsigned sz) {
327     if (sz > 0) {
328         data_ = new T[sz];
329     }
330     sz_ = tsz_ = sz;
331 }
332
333 template<class T>
334 DO_INLINE_P
335 void
336 vectordlx<T>::init(const T& v0) {
337     for (unsigned i = 0; i < sz_; ++i) {
338         data_[i] = v0;
339     }
340 }
341
342 template<class T>
343 DO_INLINE_P
344 void
345 vectordlx<T>::copy(unsigned sz, const T* data) {
346     for (unsigned i = 0; i < sz; ++i) {
347         data_[i] = data[i];
348     }
349 }
350
351 template<class T>
352 DO_INLINE_P
353 void
354 vectordlx<T>::destroy() {
355     delete[] data_; data_ = 0;
356     sz_ = tsz_ = 0;
357 }
358
359 template<class T, class U>
360 DO_INLINE_F
361 vectordlx<U>
362 map(U (*f)(const T &), const vectordlx<T>& v) {
363     vectordlx<U> ret(sz_);
364     for (unsigned i = 0; i < sz_; ++i) {
365         ret[i] = f(data_[i]);
366     }
367     return ret;
368 }
369
370 template<class T, class U>
371 DO_INLINE_F
372 U
373 fold(U (*f)(const T &, const U &), const vectordlx<T>& v, const U& arg0) {
374     U ret = arg0;
375     for (int i = sz_-1; i >= 0; --i) {
376         ret = f(data_[i], ret);
377     }
378     return ret;
379 }
380
381 template<class T, class U>
382 DO_INLINE_F
383 U
384 revfold(U (*f)(const U &, const T &), const vectordlx<T>& v, const U& arg0) {
385     U ret = arg0;
386     for (unsigned i = 0; i < sz_; ++i) {
387         ret = f(ret, data_[i]);
388     }
389     return ret;
390 }
391
392 #endif