"Fossies" - the Fresh Open Source Software Archive 
Member "portfwd-0.29/src/vector.hpp" (28 Jun 2005, 4941 Bytes) of package /linux/privat/old/portfwd-0.29.tar.gz:
As a special service "Fossies" has tried to format the requested source page into HTML format using (guessed) C and C++ source code syntax highlighting (style:
standard) with prefixed line numbers and
code folding option.
Alternatively you can here
view or
download the uninterpreted source code file.
1 // vector.hpp
2 //
3 // $Id: vector.hpp,v 1.5 2005/06/28 21:46:27 evertonm Exp $
4
5
6 #ifndef VECTOR_HPP
7 #define VECTOR_HPP
8
9 #include <syslog.h>
10 #include <stdlib.h>
11 #include <iostream>
12 #include "iterator.hpp"
13 #include "util.hpp"
14
15
16 template <typename T> class vector;
17
18 template <typename T> std::ostream& operator << (std::ostream& out, const vector<T>& v);
19
20 template <class T>
21 class vector
22 {
23 protected:
24
25 int capacity;
26 T *data;
27 T *past_end;
28
29 public:
30
31 vector(int cap = 1);
32 vector(const vector& v);
33 virtual ~vector();
34
35 const vector& operator = (const vector& v);
36
37 void push(const T& info);
38 T pop();
39 void trim();
40 void erase();
41
42 int get_capacity() const;
43 int get_size() const;
44 T& get_at(int ind) const;
45 int is_empty() const;
46
47 T& top();
48
49 void cut(T& info);
50 void cut_at(int size);
51
52 void drop(T& info);
53 void drop_at(int size);
54
55 T *begin_ptr() const;
56 T *past_end_ptr() const;
57 static T *next_ptr(T *i);
58
59 friend std::ostream& operator << <T> (std::ostream& out, const vector<T>& v);
60 };
61
62 template <class T>
63 vector<T>::vector(int cap)
64 {
65 if (cap < 1) {
66 syslog(LOG_EMERG, "%s: %s\n", "vector::vector(int)", "capacity must be a positive value");
67 exit(1);
68 }
69
70 capacity = cap;
71 data = safe_new(data, cap);
72 past_end = data;
73 }
74
75 template <class T>
76 vector<T>::vector(const vector& v)
77 {
78 capacity = v.get_size();
79 data = safe_new(data, capacity);
80 past_end = data + capacity;
81
82 T *src = v.data;
83 T *trg = data;
84 while (trg < past_end)
85 *trg++ = *src++;
86 }
87
88 template <class T>
89 inline vector<T>::~vector()
90 {
91 delete [] data;
92 }
93
94 template <class T>
95 const vector<T>& vector<T>::operator = (const vector& v)
96 {
97 if (capacity < v.get_size())
98 {
99 delete [] data;
100 capacity = v.get_size();
101 data = safe_new(data, capacity);
102 past_end = data + capacity;
103 }
104
105 T *src = v.data;
106 T *trg = data;
107 while (trg < past_end)
108 *trg++ = *src++;
109
110 return v;
111 }
112
113 template <class T>
114 void vector<T>::push(const T& info)
115 {
116 int size = get_size();
117 if (size >= capacity)
118 {
119 capacity <<= 1;
120 T* new_data = safe_new(data, capacity);
121 past_end = new_data + size;
122
123 T *src = data;
124 T *trg = new_data;
125 while (trg < past_end)
126 *trg++ = *src++;
127
128 delete [] data;
129 data = new_data;
130 }
131
132 *(past_end++) = info;
133 }
134
135 template <class T>
136 inline T vector<T>::pop()
137 {
138 if (past_end <= data) {
139 syslog(LOG_EMERG, "vector::pop(): underflow: size: %d \r\n", get_size());
140 exit(1);
141 }
142
143 return *--past_end;
144 }
145
146 template <class T>
147 void vector<T>::trim()
148 {
149 int size = get_size();
150 if (size == capacity)
151 return;
152
153 T* tight_data = safe_new(data, size);
154 past_end = tight_data + size;
155
156 T *src = data;
157 T *trg = tight_data;
158 while (trg < past_end)
159 *trg++ = *src++;
160
161 delete [] data;
162 data = tight_data;
163 capacity = size;
164 }
165
166 template <class T>
167 inline void vector<T>::erase()
168 {
169 past_end = data;
170 }
171
172 template <class T>
173 inline int vector<T>::get_capacity() const
174 {
175 return capacity;
176 }
177
178 template <class T>
179 inline int vector<T>::get_size() const
180 {
181 return past_end - data;
182 }
183
184 template <class T>
185 inline T& vector<T>::get_at(int ind) const
186 {
187 if ((ind < 0) || (data + ind >= past_end)) {
188 syslog(LOG_EMERG, "%s: %s: %d (size: %d)\n", "vector::get_at()", "index out of bounds", ind, get_size());
189 exit(1);
190 }
191
192 return data[ind];
193 }
194
195 template <class T>
196 inline int vector<T>::is_empty() const
197 {
198 return past_end == data;
199 }
200
201 template <class T>
202 inline T& vector<T>::top()
203 {
204 if (past_end <= data) {
205 syslog(LOG_EMERG, "vector::top(): empty\r\n");
206 exit(1);
207 }
208 return *(past_end - 1);
209 }
210
211 template <class T>
212 inline void vector<T>::cut(T& info)
213 {
214 while (*--past_end != info)
215 ;
216 }
217
218 template <class T>
219 inline void vector<T>::cut_at(int size)
220 {
221 T *p = data + size;
222
223 if ((size < 0) || (p > past_end)) {
224 syslog(LOG_EMERG, "%s: %s: %d (old size: %d)\n", "vector::cut_at()", "new size out of bounds", size, get_size());
225 exit(1);
226 }
227
228 past_end = p;
229 }
230
231 template <class T>
232 inline void vector<T>::drop(T& info)
233 {
234 T *p = past_end;
235
236 while (*--p != info)
237 ;
238
239 *p = *--past_end;
240 }
241
242 template <class T>
243 inline void vector<T>::drop_at(int ind)
244 {
245 T *i = data + ind;
246
247 if ((ind < 0) || (i >= past_end)) {
248 syslog(LOG_EMERG, "%s: %s: %d (size: %d)\n", "vector::drop_at()", "index out of bounds", ind, get_size());
249 exit(1);
250 }
251
252 *i = *--past_end;
253 }
254
255 template <class T>
256 inline T *vector<T>::begin_ptr() const
257 {
258 return data;
259 }
260
261 template <class T>
262 inline T *vector<T>::past_end_ptr() const
263 {
264 return past_end;
265 }
266
267 template <class T>
268 inline T *vector<T>::next_ptr(T *i)
269 {
270 return ++i;
271 }
272
273 template <class T>
274 std::ostream& operator << (std::ostream& out, const vector<T>& v)
275 {
276 out << "(" << v.get_size() << "," << v.get_capacity() << ")";
277
278 iterator<vector<T>, T> it(v);
279 for (it.start(); it.cont(); it.next())
280 out << " " << it.get();
281
282 return out;
283 }
284
285
286 #endif // VECTOR_HPP