Removal of:
[dyninst.git] / dyner / src / dynerList.h
1 /*
2  * Copyright (c) 1996-2011 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  * By your use of Paradyn, you understand and agree that we (or any
12  * other person or entity with proprietary rights in Paradyn) are
13  * under no obligation to provide either maintenance services,
14  * update services, notices of latent defects, or correction of
15  * defects for Paradyn.
16  * 
17  * This library is free software; you can redistribute it and/or
18  * modify it under the terms of the GNU Lesser General Public
19  * License as published by the Free Software Foundation; either
20  * version 2.1 of the License, or (at your option) any later version.
21  * 
22  * This library is distributed in the hope that it will be useful,
23  * but WITHOUT ANY WARRANTY; without even the implied warranty of
24  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
25  * Lesser General Public License for more details.
26  * 
27  * You should have received a copy of the GNU Lesser General Public
28  * License along with this library; if not, write to the Free Software
29  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
30  */
31
32 #ifndef __DYNERLIST__
33 #define __DYNERLIST__
34
35 #if !defined(USE_DEPRECATED_BPATCH_VECTOR)
36 #include <list>
37 #include <algorithm>
38 #define DynerList       std::list
39 #else
40
41 template<class T> 
42 class DynerList {
43         struct ListItem {
44                 T _item;
45                 ListItem *_next;
46                 ListItem() {_item = DynerList<T>::_nullT; _next = NULL; }
47                 ListItem(const T& item) { _item = item; _next = NULL; }
48         };
49
50         struct iterType {
51                 ListItem *_ptr;
52                 iterType() { _ptr = NULL; }
53                 void operator++() {
54                         if (!_ptr)
55                                 return;
56                         _ptr = _ptr->_next;
57                 }
58                 void operator++(int) {
59                         if (!_ptr)
60                                 return;
61                         _ptr = _ptr->_next;
62                 }
63                 void operator=(ListItem *item) {
64                         _ptr = item;
65                 }
66                 bool operator==(iterType& iter) {
67                         return _ptr == iter._ptr;
68                 }
69                 bool operator!=(iterType& iter) {
70                         return _ptr != iter._ptr;
71                 }
72                 T& operator*() {
73                         return _ptr->_item;
74                 }
75         };
76
77         iterType _begin;
78         iterType _end;
79         ListItem *_vector;
80         int _size;
81 public:
82         static T _nullT;
83         typedef iterType iterator;
84
85         DynerList();
86         ~DynerList();
87
88         const T& operator[](int n) const;
89         bool erase(iterType &x);
90         void clear();
91         void push_back(const T& x);
92         void push_front(const T& x);
93         int size() { return _size; }
94         iterator& begin() { 
95                 if (_vector)
96                         _begin._ptr = _vector;
97                 else
98                         _begin = _end;
99                 return _begin; 
100         }
101         iterator& end() { return _end; }
102 };
103
104 template<class T>
105 DynerList<T>::DynerList() { 
106         _vector = NULL;
107         _size = 0;
108 }
109
110 template<class T>
111 DynerList<T>::~DynerList() { 
112         clear();
113 }
114
115 template<class T>
116 const T& DynerList<T>::operator[](int n) const {
117         if ( (n<0) || (n>_size-1) )
118                 return _nullT;
119
120         ListItem *item = _vector;
121
122         for(int i=0; i <= n; ++i)
123                 item = item->_next;
124
125         return item->_item;
126 }
127
128 template<class T>
129 bool DynerList<T>::erase(iterType &x) {
130         ListItem *item, *prev;
131
132         prev = item = _vector;
133
134         while(item) {
135                 if (item == x._ptr)
136                         break;
137
138                 prev = item;
139                 item = item->_next;
140         }
141
142         if (!item)
143                 return false;
144
145         if (item == _vector) {
146                 _vector = _vector->_next;
147                 x._ptr = _vector;    
148         }else {
149                 prev->_next = item->_next;
150                 x._ptr = prev;  
151         }
152
153         delete item;
154         return true;
155 }
156
157 template<class T>
158 void DynerList<T>::clear() {
159         ListItem *prev;
160
161         while(_vector) {
162                 prev = _vector;
163                 _vector = _vector->_next;
164                 delete prev;
165         }
166         _vector = NULL;
167         _size = 0;
168 }
169
170
171 template<class T>
172 void DynerList<T>::push_back(const T& x) {
173         if (!_vector) {
174                 _vector = new ListItem(x);
175                 return;
176         }
177
178         ListItem *item = _vector;
179         while(item->_next)
180                 item = item->_next;
181
182         item->_next = new ListItem(x);
183 }
184
185 template<class T>
186 void DynerList<T>::push_front(const T& x) {
187
188         ListItem *item = new ListItem(x);
189         item->_next = _vector;
190         _vector = item;
191 }
192
193 template<class T> T DynerList<T>::_nullT;
194
195 #endif
196
197 #endif //__DYNERLIST__