*** empty log message ***
[dyninst.git] / dyner / src / dynerList.h
1 #ifndef __DYNERLIST__
2 #define __DYNERLIST__
3
4 template<class T> 
5 class DynerList {
6         struct ListItem {
7                 T _item;
8                 ListItem *_next;
9                 ListItem() {_item = _nullT; _next = NULL; }
10                 ListItem(const T& item) { _item = item; _next = NULL; }
11         };
12
13         struct iterType {
14                 ListItem *_ptr;
15                 iterType() { _ptr = NULL; }
16                 void operator++() {
17                         if (!_ptr)
18                                 return;
19                         _ptr = _ptr->_next;
20                 }
21                 void operator++(int) {
22                         if (!_ptr)
23                                 return;
24                         _ptr = _ptr->_next;
25                 }
26                 void operator=(ListItem *item) {
27                         _ptr = item;
28                 }
29                 bool operator==(iterType& iter) {
30                         return _ptr == iter._ptr;
31                 }
32                 bool operator!=(iterType& iter) {
33                         return _ptr != iter._ptr;
34                 }
35                 T& operator*() {
36                         return _ptr->_item;
37                 }
38         };
39
40         T _nullT;
41         iterType _begin;
42         iterType _end;
43         ListItem *_vector;
44         int _size;
45 public:
46         typedef iterType iterator;
47
48         DynerList();
49         ~DynerList();
50
51         const T& operator[](int n) const;
52         bool erase(const T& x);
53         void clear();
54         void push_back(const T& x);
55         void push_front(const T& x);
56         int size() { return _size; }
57         iterator& begin() { 
58                 if (_vector)
59                         _begin._ptr = _vector;
60                 else
61                         _begin = _end;
62                 return _begin; 
63         }
64         iterator& end() { return _end; }
65 };
66
67 template<class T>
68 DynerList<T>::DynerList() { 
69         _vector = NULL;
70         _size = 0;
71 }
72
73 template<class T>
74 DynerList<T>::~DynerList() { 
75         clear();
76 }
77
78 template<class T>
79 const T& DynerList<T>::operator[](int n) const {
80         if ( (n<0) || (n>_size-1) )
81                 return _nullT;
82
83         ListItem *item = _vector;
84
85         for(int i=0; i <= n; ++i)
86                 item = item->_next;
87
88         return item->_item;
89 }
90
91 template<class T>
92 bool DynerList<T>::erase(const T& x) {
93         ListItem *item, *prev;
94
95         prev = item = _vector;
96
97         while(item) {
98                 if (item->_item == x)
99                         break;
100
101                 prev = item;
102                 item = item->_next;
103         }
104
105         if (!item)
106                 return false;
107
108         if (item == _vector)
109                 _vector = _vector->_next;
110         else
111                 prev->_next = item->_next;
112
113         delete item;
114         return true;
115 }
116
117 template<class T>
118 void DynerList<T>::clear() {
119         ListItem *prev;
120
121         while(_vector) {
122                 prev = _vector;
123                 _vector = _vector->_next;
124                 delete prev;
125         }
126         _vector = NULL;
127         _size = 0;
128 }
129
130
131 template<class T>
132 void DynerList<T>::push_back(const T& x) {
133         if (!_vector) {
134                 _vector = new ListItem(x);
135                 return;
136         }
137
138         ListItem *item = _vector;
139         while(item->_next)
140                 item = item->_next;
141
142         item->_next = new ListItem(x);
143 }
144
145 template<class T>
146 void DynerList<T>::push_front(const T& x) {
147
148         ListItem *item = new ListItem(x);
149         item->_next = _vector;
150         _vector = item;
151 }
152
153 #endif //__DYNERLIST__