ViewVC Help
View File | Revision Log | Show Annotations | Download File
/cvs/libptytty/src/estl.h
(Generate patch)

Comparing libptytty/src/estl.h (file contents):
Revision 1.2 by sf-exg, Sat Jan 21 13:44:38 2012 UTC vs.
Revision 1.8 by root, Fri May 18 00:10:51 2012 UTC

1#ifndef ESTL_H 1#ifndef ESTL_H_
2#define ESTL_H 2#define ESTL_H_
3 3
4#include <stdlib.h> 4#include <stdlib.h>
5#include <string.h> 5#include <string.h>
6 6
7template<typename T, typename U> static inline T min (T a, U b) { return a < (T)b ? a : (T)b; } 7template<typename T, typename U> static inline T min (T a, U b) { return a < (T)b ? a : (T)b; }
8template<typename T, typename U> static inline T max (T a, U b) { return a > (T)b ? a : (T)b; } 8template<typename T, typename U> static inline T max (T a, U b) { return a > (T)b ? a : (T)b; }
9 9
10template<typename T, typename U> static inline void swap (T& a, U& b) { T t=a; a=(T)b; b=(U)t; } 10template<typename T, typename U> static inline void swap (T& a, U& b) { T t = a; a = (T)b; b = (U)t; }
11 11
12template <typename I, typename T> 12template <typename I, typename T>
13I find (I first, I last, const T& value) 13I find (I first, I last, const T& value)
14{ 14{
15 while (first != last && *first != value) 15 while (first != last && *first != value)
16 ++first; 16 ++first;
17 17
18 return first; 18 return first;
19} 19}
20
21// see ecb.h for details
22#ifndef ECB_GCC_VERSION
23 #if !defined __GNUC_MINOR__ || defined __INTEL_COMPILER || defined __SUNPRO_C || defined __SUNPRO_CC || defined __llvm__ || defined __clang__
24 #define ECB_GCC_VERSION(major,minor) 0
25 #else
26 #define ECB_GCC_VERSION(major,minor) (__GNUC__ > (major) || (__GNUC__ == (major) && __GNUC_MINOR__ >= (minor)))
27 #endif
28#endif
29
30#include <new>
31
32#if __cplusplus >= 201103L
33 #include <type_traits>
34#endif
20 35
21/* simplevec taken (and heavily modified), from: 36/* simplevec taken (and heavily modified), from:
22 * 37 *
23 * MICO --- a free CORBA implementation 38 * MICO --- a free CORBA implementation
24 * Copyright (C) 1997-98 Kay Roemer & Arno Puder 39 * Copyright (C) 1997-98 Kay Roemer & Arno Puder
40 * originally GPLv2 or any later
25 */ 41 */
26template<class T> 42template<class T>
27struct simplevec 43struct simplevec
28{ 44{
29 typedef T* iterator; 45 typedef T *iterator;
30 typedef const T* const_iterator; 46 typedef const T *const_iterator;
31 typedef unsigned long size_type; 47 typedef unsigned long size_type;
48
49 static bool is_simple_enough ()
50 {
51 #if __cplusplus >= 201103L
52 return std::is_trivially_assignable<T, T>::value
53 && std::is_trivially_constructable<T>::value
54 && std::is_trivially_copyable<T>::value
55 && std::is_trivially_destructible<T>::value;
56 #elif ECB_GCC_VERSION(4,4)
57 return __has_trivial_assign (T)
58 && __has_trivial_constructor (T)
59 && __has_trivial_copy (T)
60 && __has_trivial_destructor (T);
61 #else
62 return 0;
63 #endif
64 }
32 65
33private: 66private:
34 size_type _last, _size; 67 size_type _last, _size;
35 T *_buf; 68 T *_buf;
36 69
37public: 70public:
38 const_iterator begin () const 71 const_iterator begin () const { return &_buf[0]; }
72 iterator begin () { return &_buf[0]; }
73
74 const_iterator end () const { return &_buf[_last]; }
75 iterator end () { return &_buf[_last]; }
76
77 size_type capacity () const { return _size; }
78 size_type size () const { return _last; }
79
80private:
81 static T *alloc (size_type n)
82 {
83 return (T *)::operator new ((size_t) (n * sizeof (T)));
84 }
85
86 void dealloc ()
87 {
88 if (!is_simple_enough ())
89 for (size_type i = 0; i < _last; ++i)
90 _buf [i].~T ();
91
92 ::operator delete (_buf);
93 }
94
95 size_type good_size (size_type n)
96 {
97 return max (n, _size ? _size * 2 : 5);
98 }
99
100 // these copy helpers actually use the copy constructor, not assignment
101 static void copy_lower (iterator dst, iterator src, size_type n)
102 {
103 if (is_simple_enough ())
104 memmove (dst, src, sizeof (T) * n);
105 else
106 while (n--)
107 new (dst++) T (*src++);
108 }
109
110 static void copy_higher (iterator dst, iterator src, size_type n)
111 {
112 if (is_simple_enough ())
113 memmove (dst, src, sizeof (T) * n);
114 else
115 while (n--)
116 new (dst + n) T (*(src + n));
117 }
118
119 static void copy (iterator dst, iterator src, size_type n)
120 {
121 if (is_simple_enough ())
122 memcpy (dst, src, sizeof (T) * n);
123 else
124 copy_lower (dst, src, n);
125 }
126
127 void ins (iterator where, size_type n)
128 {
129 if (_last + n <= _size)
130 copy_higher (where + n, where, end () - where);
131 else
132 {
133 size_type sz = _last + n;
134 sz = good_size (sz);
135 T *nbuf = alloc (sz);
136
137 if (_buf)
138 {
139 copy (nbuf, begin (), where - begin ());
140 copy (nbuf + (where - begin ()) + n, where, end () - where);
141 dealloc ();
142 }
143
144 _buf = nbuf;
145 _size = sz;
146 }
147 }
148
149public:
150 void reserve (size_type sz)
151 {
152 if (_size < sz)
153 {
154 sz = good_size (sz);
155 T *nbuf = alloc (sz);
156
157 if (_buf)
158 {
159 copy (nbuf, begin (), _last);
160 dealloc ();
161 }
162
163 _buf = nbuf;
164 _size = sz;
165 }
166 }
167
168 void resize (size_type sz)
169 {
170 reserve (sz);
171
172 if (is_simple_enough ())
173 _last = sz;
174 else
175 {
176 while (_last < sz)
177 new (_buf + _last++) T ();
178 while (_last > sz)
179 _buf [--_last].~T ();
180 }
181 }
182
183 simplevec ()
184 : _last(0), _size(0), _buf(0)
185 {
186 }
187
188 simplevec (size_type n, const T& t = T ())
189 : _last(0), _size(0), _buf(0)
190 {
191 insert (begin (), n, t);
192 }
193
194 simplevec (const_iterator first, const_iterator last)
195 : _last(0), _size(0), _buf(0)
196 {
197 insert (begin (), first, last);
198 }
199
200 simplevec (const simplevec<T> &v)
201 : _last(0), _size(0), _buf(0)
202 {
203 insert (begin (), v.begin (), v.end ());
204 }
205
206 simplevec<T> &operator= (const simplevec<T> &v)
207 {
208 if (this != &v)
209 {
210
211 dealloc ();
212 _size = 0;
213 _buf = 0;
214 _last = 0;
215 reserve (v._last);
216
217 copy (_buf, v.begin (), v.size ());
218 _last = v._last;
219 }
220
221 return *this;
222 }
223
224 ~simplevec ()
225 {
226 dealloc ();
227 }
228
229 const T &front () const { return _buf[ 0]; }
230 T &front () { return _buf[ 0]; }
231 const T &back () const { return _buf[_last-1]; }
232 T &back () { return _buf[_last-1]; }
233
234 bool empty () const
235 {
236 return _last == 0;
237 }
238
239 void clear ()
240 {
241 _last = 0;
242 }
243
244 void push_back (const T &t)
245 {
246 reserve (_last + 1);
247 new (_buf + _last++) T (t);
248 }
249
250 void pop_back ()
251 {
252 --_last;
253 }
254
255 const T &operator [](size_type idx) const { return _buf[idx]; }
256 T &operator [](size_type idx) { return _buf[idx]; }
257
258 iterator insert (iterator pos, const T &t)
259 {
260 size_type at = pos - begin ();
261 ins (pos, 1);
262 pos = begin () + at;
263 *pos = t;
264 ++_last;
265 return pos;
266 }
267
268 iterator insert (iterator pos, const_iterator first, const_iterator last)
269 {
270 size_type n = last - first;
271 size_type at = pos - begin ();
272
273 if (n > 0)
274 {
275 ins (pos, n);
276 _last += n;
277 copy (pos, first, n);
278 }
279
280 return pos;
281 }
282
283 iterator insert (iterator pos, size_type n, const T &t)
284 {
285 size_type at = pos - begin ();
286
287 if (n > 0)
288 {
289 ins (pos, n);
290 pos = begin () + at;
291 for (size_type i = 0; i < n; ++i)
292 pos[i] = t;
293 _last += n;
294 }
295
296 return pos;
297 }
298
299 void erase (iterator first, iterator last)
300 {
301 if (last != first)
302 {
303 if (!is_simple_enough ())
304 for (iterator i = first; i < last; ++i)
305 i->~T ();
306
307 copy_lower (last, first, end () - last);
308
309 _last -= last - first;
310 }
311 }
312
313 void erase (iterator pos)
314 {
315 if (pos != end ())
316 erase (pos, pos + 1);
317 }
318
319 void swap (simplevec<T> &t)
320 {
321 ::swap (_last, t._last);
322 ::swap (_size, t._size);
323 ::swap (_buf , t._buf );
324 }
325};
326
327template<class T>
328bool operator ==(const simplevec<T> &v1, const simplevec<T> &v2)
329{
330 if (v1.size () != v2.size ()) return false;
331
332 return !v1.size () || !memcmp (&v1[0], &v2[0], v1.size () * sizeof (T));
333}
334
335template<class T>
336bool operator <(const simplevec<T> &v1, const simplevec<T> &v2)
337{
338 unsigned long minlast = min (v1.size (), v2.size ());
339
340 for (unsigned long i = 0; i < minlast; ++i)
39 { 341 {
40 return &_buf[0]; 342 if (v1[i] < v2[i]) return true;
343 if (v2[i] < v1[i]) return false;
41 } 344 }
42 iterator begin ()
43 {
44 return &_buf[0];
45 }
46 const_iterator end () const
47 {
48 return &_buf[_last];
49 }
50 iterator end ()
51 {
52 return &_buf[_last];
53 }
54 size_type capacity () const
55 {
56 return _size;
57 }
58 size_type size () const
59 {
60 return _last;
61 }
62
63private:
64 static T *alloc (size_type n)
65 {
66 return (T *)::operator new ((size_t) (n * sizeof (T)));
67 }
68 static void dealloc (T *buf)
69 {
70 if (buf)
71 ::operator delete (buf);
72 }
73
74 void reserve (iterator where, size_type n)
75 {
76 if (_last + n <= _size) {
77 memmove (where+n, where, (end ()-where)*sizeof (T));
78 } else {
79 size_type sz = _last+n;
80 sz = (_size == 0) ? max (sz, 5) : max (sz, 2*_size);
81 T *nbuf = alloc (sz);
82 if (_buf) {
83 memcpy (nbuf, begin (), (where-begin ())*sizeof (T));
84 memcpy (nbuf + (where-begin ()) + n, where,
85 (end ()-where)*sizeof (T));
86 dealloc (_buf);
87 }
88 _buf = nbuf;
89 _size = sz;
90 }
91 }
92
93public:
94 void reserve (size_type sz)
95 {
96 if (_size < sz) {
97 sz = (_size == 0) ? max (sz, 5) : max (sz, 2*_size);
98 T *nbuf = alloc (sz);
99 if (_buf) {
100 memcpy (nbuf, begin (), size ()*sizeof (T));
101 dealloc (_buf);
102 }
103 _buf = nbuf;
104 _size = sz;
105 }
106 }
107 simplevec ()
108 : _last(0), _size(0), _buf(0)
109 {
110 }
111 simplevec (size_type n, const T& t = T ())
112 : _last(0), _size(0), _buf(0)
113 {
114 insert (begin (), n, t);
115 }
116 simplevec (const_iterator first, const_iterator last)
117 : _last(0), _size(0), _buf(0)
118 {
119 insert (begin (), first, last);
120 }
121 simplevec (const simplevec<T> &v)
122 : _last(0), _size(0), _buf(0)
123 {
124 reserve (v._last);
125 memcpy (_buf, v.begin (), v.size ()*sizeof (T));
126 _last = v._last;
127 }
128 simplevec<T> &operator= (const simplevec<T> &v)
129 {
130 if (this != &v) {
131 _last = 0;
132 reserve (v._last);
133 memcpy (_buf, v.begin (), v.size ()*sizeof (T));
134 _last = v._last;
135 }
136 return *this;
137 }
138 ~simplevec ()
139 {
140 dealloc (_buf);
141 }
142 const T &front () const
143 {
144 //ministl_assert (size () > 0);
145 return _buf[0];
146 }
147 T &front ()
148 {
149 //ministl_assert (size () > 0);
150 return _buf[0];
151 }
152 const T &back () const
153 {
154 //ministl_assert (size () > 0);
155 return _buf[_last-1];
156 }
157 T &back ()
158 {
159 //ministl_assert (size () > 0);
160 return _buf[_last-1];
161 }
162 bool empty () const
163 {
164 return _last == 0;
165 }
166 void clear ()
167 {
168 _last = 0;
169 }
170 void push_back (const T &t)
171 {
172 reserve (_last+1);
173 *end () = t;
174 ++_last;
175 }
176 void push_back (T &t)
177 {
178 reserve (_last+1);
179 *end () = t;
180 ++_last;
181 }
182 void pop_back ()
183 {
184 //ministl_assert (size () > 0);
185 --_last;
186 }
187 const T &operator[] (size_type idx) const
188 {
189 //ministl_assert (idx < size ());
190 return _buf[idx];
191 }
192 T &operator[] (size_type idx)
193 {
194 //ministl_assert (idx < size ());
195 return _buf[idx];
196 }
197 iterator insert (iterator pos, const T &t)
198 {
199 //ministl_assert (pos <= end ());
200 long at = pos - begin ();
201 reserve (pos, 1);
202 pos = begin ()+at;
203 *pos = t;
204 ++_last;
205 return pos;
206 }
207 iterator insert (iterator pos, const_iterator first, const_iterator last)
208 {
209 //ministl_assert (pos <= end ());
210 long n = last - first;
211 long at = pos - begin ();
212 if (n > 0) {
213 reserve (pos, n);
214 pos = begin ()+at;
215 memcpy (pos, first, (last-first)*sizeof (T));
216 _last += n;
217 }
218 return pos;
219 }
220 iterator insert (iterator pos, size_type n, const T &t)
221 {
222 //ministl_assert (pos <= end ());
223 long at = pos - begin ();
224 if (n > 0) {
225 reserve (pos, n);
226 pos = begin ()+at;
227 for (int i = 0; i < n; ++i)
228 pos[i] = t;
229 _last += n;
230 }
231 return pos;
232 }
233 void erase (iterator first, iterator last)
234 {
235 if (last != first) {
236 memmove (first, last, (end () - last) * sizeof (T));
237 _last -= last - first;
238 }
239 }
240 void erase (iterator pos)
241 {
242 if (pos != end ()) {
243 memmove (pos, pos+1, (end () - (pos+1)) * sizeof (T));
244 --_last;
245 }
246 }
247 void swap (simplevec<T> &t)
248 {
249 ::swap(_last, t._last);
250 ::swap(_size, t._size);
251 ::swap(_buf, t._buf);
252 }
253};
254
255template<class T>
256bool operator== (const simplevec<T> &v1, const simplevec<T> &v2)
257{
258 if (v1.size () != v2.size ())
259 return false;
260 return !v1.size () || !memcmp (&v1[0], &v2[0], v1.size ()*sizeof (T));
261}
262
263template<class T>
264bool operator< (const simplevec<T> &v1, const simplevec<T> &v2)
265{
266 unsigned long minlast = min (v1.size (), v2.size ());
267 for (unsigned long i = 0; i < minlast; ++i) {
268 if (v1[i] < v2[i])
269 return true;
270 if (v2[i] < v1[i])
271 return false;
272 }
273 return v1.size () < v2.size (); 345 return v1.size () < v2.size ();
274} 346}
275 347
276template<typename T> 348template<typename T>
277struct vector : simplevec<T> 349struct vector : simplevec<T>
278{ 350{
279}; 351};
280 352
281#endif 353#endif
354

Diff Legend

– Removed lines
+ Added lines
< Changed lines
> Changed lines