Fixed strcmp for .dynamic section
[dyninst.git] / common / h / Vector.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  * Vector.h: resizable vectors.
44  * $Id: Vector.h,v 1.8 1999/07/28 19:21:38 nash Exp $
45 ************************************************************************/
46
47
48 \f
49
50
51 #if !defined(_Vector_h_)
52 #define _Vector_h_
53
54 #if defined(external_templates)
55 #pragma interface
56 #endif
57
58 \f
59
60 /************************************************************************
61  * header files.
62 ************************************************************************/
63
64 #include <assert.h>
65 #include <stdlib.h>
66
67
68 \f
69
70 /************************************************************************
71  * template<class T> class Vector
72 ************************************************************************/
73
74 #if !defined(DO_INLINE_P)
75 #define DO_INLINE_P
76 #endif
77
78 #if !defined(DO_INLINE_F)
79 #define DO_INLINE_F
80 #endif
81
82 template<class T>
83 class vector {
84 public:
85     DO_INLINE_F vector (unsigned =0);
86     DO_INLINE_F vector (unsigned, const T &);
87     DO_INLINE_F vector (const vector<T> &);
88     DO_INLINE_F ~vector ();
89
90     DO_INLINE_F vector<T>&  operator= (const vector<T> &);
91     DO_INLINE_F vector<T>& operator+= (const vector<T> &);
92     DO_INLINE_F vector<T>& operator+= (const T &);
93
94     DO_INLINE_F T&         operator[] (unsigned)                               const;
95     DO_INLINE_F bool       operator== (const vector<T> &)                      const;
96     DO_INLINE_F unsigned         size ()                                       const;
97     DO_INLINE_F void           resize (unsigned);
98
99         DO_INLINE_F vector<T>&     insert (unsigned, const vector<T> &);
100         DO_INLINE_F vector<T>&     insert (unsigned, const T &);
101
102     DO_INLINE_F void             sort (int (*)(const void *, const void *));
103
104 private:
105     DO_INLINE_P void  create (unsigned);
106     DO_INLINE_P void    init (const T &);
107     DO_INLINE_P void    copy (unsigned, const T *);
108     DO_INLINE_P void destroy ();
109
110     T*       data_;
111     unsigned sz_;
112     unsigned tsz_;
113 };
114
115 template<class T>
116 DO_INLINE_F
117 vector<T>::vector(unsigned sz)
118     : data_(0), sz_(0), tsz_(0) {
119     create(sz);
120 }
121
122 template<class T>
123 DO_INLINE_F
124 vector<T>::vector(unsigned sz, const T& v0)
125     : data_(0), sz_(0), tsz_(0) {
126     create(sz);
127     init(v0);
128 }
129
130
131 template<class T>
132 DO_INLINE_F
133 vector<T>::vector(const vector<T>& v)
134     : data_(0), sz_(0), tsz_(0) {
135     create(v.sz_);
136     copy(v.sz_, v.data_);
137 }
138
139 template<class T>
140 DO_INLINE_F
141 vector<T>::~vector() {
142     destroy();
143 }
144
145 template<class T>
146 DO_INLINE_F
147 vector<T>&
148 vector<T>::operator=(const vector<T>& v) {
149     if (this == &v) {
150         return *this;
151     }
152     destroy();
153     create(v.sz_);
154     copy(v.sz_, v.data_);
155     return *this;
156 }
157
158 template<class T>
159 DO_INLINE_F
160 vector<T>&
161 vector<T>::operator+=(const vector<T>& v) {
162     unsigned osz = sz_;
163     resize(osz + v.sz_);
164     for (unsigned i = osz; i < sz_; ++i) {
165         data_[i] = v.data_[i-osz];
166     }
167     return *this;
168 }
169
170 template<class T>
171 DO_INLINE_F
172 vector<T>&
173 vector<T>::operator+=(const T& v0) {
174     resize(sz_+1);
175     data_[sz_-1] = v0;
176     return *this;
177 }
178
179 template<class T>
180 DO_INLINE_F
181 vector<T>&
182 vector<T>::insert(unsigned l, const vector<T>& v) {
183         unsigned osz = sz_, i;
184         resize(osz+v.sz_);
185         if( l > osz )
186                 l = osz ;
187         if( osz != 0 ) {
188                 for(i = osz-1; i >= l; --i ) {
189                         data_[i+v.sz_] = data_[i];
190                 }
191         }
192         for(i = l; i < l+v.sz_; ++i ) {
193                 data_[i] = v.data_[i-l];
194         }
195     return *this;
196 }
197
198 template<class T>
199 DO_INLINE_F
200 vector<T>&
201 vector<T>::insert(unsigned l, const T& v0) {
202         unsigned osz = sz_, i;
203         resize(osz+1);
204         if( l > osz )
205                 l = osz;
206         if( osz != 0 ) {
207                 for(i = osz-1; i >= l; --i ) {
208                         data_[i+1] = data_[i];
209                 }
210         }
211         data_[l] = v0;
212     return *this;
213 }
214
215 template<class T>
216 DO_INLINE_F
217 T&
218 vector<T>::operator[](unsigned i) const {
219     assert(i < sz_);
220     return data_[i];
221 }
222
223 template<class T>
224 DO_INLINE_F
225 bool
226 vector<T>::operator==(const vector<T>& v) const {
227     if (sz_ != v.sz_) {
228         return false;
229     }
230 // TODO
231 #if defined(notdef)
232     for (unsigned i = 0; i < sz_; i++) {
233         if (!(data_[i] == v.data_[i])) {
234             return false;
235         }
236     }
237 #endif
238     return true;
239 }
240
241 template<class T>
242 DO_INLINE_F
243 unsigned
244 vector<T>::size() const {
245     return sz_;
246 }
247
248 template<class T>
249 DO_INLINE_F
250 void
251 vector<T>::resize(unsigned sz) {
252     if (tsz_ == 0) {
253         create(sz);
254     }
255     else if (tsz_ >= sz) {
256         sz_ = sz;
257     }
258     else {
259         T*       odata = data_;
260         unsigned osz   = sz_;
261         unsigned nsz   = (((2*tsz_)>sz)?(2*tsz_):(sz));
262
263         data_ = new T[nsz];
264         tsz_  = nsz;
265         sz_   = sz;
266
267         for (unsigned i = 0; i < osz; ++i) {
268             data_[i] = odata[i];
269         }
270         delete[] odata;
271
272         sz_ = sz;
273     }
274 }
275
276 template<class T>
277 DO_INLINE_F
278 void
279 vector<T>::sort(int (*cmpfunc)(const void *, const void *)) {
280     qsort((void *) data_, sz_, sizeof(T), cmpfunc);
281 }
282
283 template<class T>
284 DO_INLINE_P
285 void
286 vector<T>::create(unsigned sz) {
287     if (sz > 0) {
288         data_ = new T[sz];
289     }
290     sz_ = tsz_ = sz;
291 }
292
293 template<class T>
294 DO_INLINE_P
295 void
296 vector<T>::init(const T& v0) {
297     for (unsigned i = 0; i < sz_; ++i) {
298         data_[i] = v0;
299     }
300 }
301
302 template<class T>
303 DO_INLINE_P
304 void
305 vector<T>::copy(unsigned sz, const T* data) {
306     for (unsigned i = 0; i < sz; ++i) {
307         data_[i] = data[i];
308     }
309 }
310
311 template<class T>
312 DO_INLINE_P
313 void
314 vector<T>::destroy() {
315     delete[] data_; data_ = 0;
316     sz_ = tsz_ = 0;
317 }
318
319 template<class T>
320 DO_INLINE_P
321 bool
322 find(const vector<T> &v, const T &v0, unsigned &l) {
323         unsigned i, sz;
324         sz = v.size();
325         for( i = 0; i < sz; ++i ) {
326                 if( v[ i ] == v0 ) {
327                         l = i;
328                         return true;
329                 }
330         }
331         return false;
332 }
333
334 #endif /* !defined(_Vector_h_) */