Introduce rs6000-ibm-aix64 platform.
[dyninst.git] / dyner / src / dynerList.h
1 /*
2  * Copyright (c) 1996-2004 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 #ifndef __DYNERLIST__
43 #define __DYNERLIST__
44
45 #if !defined(USE_DEPRECATED_BPATCH_VECTOR)
46 #include <list>
47 #include <algorithm>
48 #define DynerList       std::list
49 #else
50
51 template<class T> 
52 class DynerList {
53         struct ListItem {
54                 T _item;
55                 ListItem *_next;
56                 ListItem() {_item = DynerList<T>::_nullT; _next = NULL; }
57                 ListItem(const T& item) { _item = item; _next = NULL; }
58         };
59
60         struct iterType {
61                 ListItem *_ptr;
62                 iterType() { _ptr = NULL; }
63                 void operator++() {
64                         if (!_ptr)
65                                 return;
66                         _ptr = _ptr->_next;
67                 }
68                 void operator++(int) {
69                         if (!_ptr)
70                                 return;
71                         _ptr = _ptr->_next;
72                 }
73                 void operator=(ListItem *item) {
74                         _ptr = item;
75                 }
76                 bool operator==(iterType& iter) {
77                         return _ptr == iter._ptr;
78                 }
79                 bool operator!=(iterType& iter) {
80                         return _ptr != iter._ptr;
81                 }
82                 T& operator*() {
83                         return _ptr->_item;
84                 }
85         };
86
87         iterType _begin;
88         iterType _end;
89         ListItem *_vector;
90         int _size;
91 public:
92         static T _nullT;
93         typedef iterType iterator;
94
95         DynerList();
96         ~DynerList();
97
98         const T& operator[](int n) const;
99         bool erase(iterType &x);
100         void clear();
101         void push_back(const T& x);
102         void push_front(const T& x);
103         int size() { return _size; }
104         iterator& begin() { 
105                 if (_vector)
106                         _begin._ptr = _vector;
107                 else
108                         _begin = _end;
109                 return _begin; 
110         }
111         iterator& end() { return _end; }
112 };
113
114 template<class T>
115 DynerList<T>::DynerList() { 
116         _vector = NULL;
117         _size = 0;
118 }
119
120 template<class T>
121 DynerList<T>::~DynerList() { 
122         clear();
123 }
124
125 template<class T>
126 const T& DynerList<T>::operator[](int n) const {
127         if ( (n<0) || (n>_size-1) )
128                 return _nullT;
129
130         ListItem *item = _vector;
131
132         for(int i=0; i <= n; ++i)
133                 item = item->_next;
134
135         return item->_item;
136 }
137
138 template<class T>
139 bool DynerList<T>::erase(iterType &x) {
140         ListItem *item, *prev;
141
142         prev = item = _vector;
143
144         while(item) {
145                 if (item == x._ptr)
146                         break;
147
148                 prev = item;
149                 item = item->_next;
150         }
151
152         if (!item)
153                 return false;
154
155         if (item == _vector) {
156                 _vector = _vector->_next;
157                 x._ptr = _vector;    
158         }else {
159                 prev->_next = item->_next;
160                 x._ptr = prev;  
161         }
162
163         delete item;
164         return true;
165 }
166
167 template<class T>
168 void DynerList<T>::clear() {
169         ListItem *prev;
170
171         while(_vector) {
172                 prev = _vector;
173                 _vector = _vector->_next;
174                 delete prev;
175         }
176         _vector = NULL;
177         _size = 0;
178 }
179
180
181 template<class T>
182 void DynerList<T>::push_back(const T& x) {
183         if (!_vector) {
184                 _vector = new ListItem(x);
185                 return;
186         }
187
188         ListItem *item = _vector;
189         while(item->_next)
190                 item = item->_next;
191
192         item->_next = new ListItem(x);
193 }
194
195 template<class T>
196 void DynerList<T>::push_front(const T& x) {
197
198         ListItem *item = new ListItem(x);
199         item->_next = _vector;
200         _vector = item;
201 }
202
203 template<class T> T DynerList<T>::_nullT;
204
205 #endif
206
207 #endif //__DYNERLIST__