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.7 by root, Thu May 17 18:06:38 2012 UTC vs.
Revision 1.28 by sf-exg, Mon Nov 10 11:32:00 2014 UTC

… …
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
7#include "ecb.h"
8
7template<typename T, typename U> static inline T min (T a, U b) { return a < (T)b ? a : (T)b; } 9template<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; } 10template<typename T, typename U> static inline T max (T a, U b) { return a > (T)b ? a : (T)b; }
9 11
10template<typename T, typename U> static inline void swap (T& a, U& b) { T t = a; a = (T)b; b = (U)t; } 12template<typename T, typename U> static inline void swap (T& a, U& b) { T t = a; a = (T)b; b = (U)t; }
11 13
… …
16 ++first; 18 ++first;
17 19
18 return first; 20 return first;
19} 21}
20 22
21/* simplevec taken (and heavily modified), from: 23#include <new>
22 * 24
23 * MICO --- a free CORBA implementation 25#if ECB_CPP11
24 * Copyright (C) 1997-98 Kay Roemer & Arno Puder 26 #include <type_traits>
25 * originally GPLv2 or any later 27#endif
26 */ 28
29namespace estl
30{
31#if ESTL_LARGE_MEMORY_MODEL
32 // should use size_t/ssize_t, but that's not portable enough for us
33 typedef unsigned long size_type;
34 typedef long difference_type;
35#else
36 typedef uint32_t size_type;
37 typedef int32_t difference_type;
38#endif
39
40 template<typename T>
41 struct scoped_ptr
42 {
43 T *p;
44
45 scoped_ptr () : p (0) { }
46
47 explicit
48 scoped_ptr (T *a) : p (a) { }
49
50 ~scoped_ptr ()
51 {
52 delete p;
53 }
54
55 void reset (T *a)
56 {
57 delete p;
58 p = a;
59 }
60
61 T *operator ->() const { return p; }
62 T &operator *() const { return *p; }
63
64 operator T *() { return p; }
65 T *get () const { return p; }
66 };
67
68 template<typename T>
69 struct scoped_array
70 {
71 T *p;
72
73 scoped_array () : p (0) { }
74
75 explicit
76 scoped_array (T *a) : p (a) { }
77
78 ~scoped_array ()
79 {
80 delete [] p;
81 }
82
83 void reset (T *a)
84 {
85 delete [] p;
86 p = a;
87 }
88
89 T & operator [](size_type idx) const { return p[idx]; }
90
91 operator T *() { return p; }
92 T *get () const { return p; }
93 };
94}
95
96// original version taken from MICO, but this has been completely rewritten
97// known limitations w.r.t. std::vector
98// - many methods missing
99// - no error checking, no exceptions thrown (e.g. at())
100// - size_type is 32bit even on 64 bit hosts, so limited to 2**31 elements
101// - no allocator support
102// - we don't really care about const correctness, but we try
103// - we don't care about namespaces and stupid macros the user might define
104// - no bool specialisation
27template<class T> 105template<class T>
28struct simplevec 106struct simplevec
29{ 107{
108 typedef estl::size_type size_type;
109
110 typedef T value_type;
30 typedef T *iterator; 111 typedef T *iterator;
31 typedef const T *const_iterator; 112 typedef const T *const_iterator;
32 typedef unsigned long size_type; 113 typedef T *pointer;
114 typedef const T *const_pointer;
115 typedef T &reference;
116 typedef const T &const_reference;
117 // missing: allocator_type
118 // missing: reverse iterator
33 119
34private: 120private:
35 size_type _last, _size; 121 size_type sze, res;
36 T *_buf; 122 T *buf;
123
124 // we shamelessly optimise for "simple" types. everything
125 // "not simple enough" will use the slow path.
126 static bool is_simple_enough ()
127 {
128 #if ECB_CPP11
129 return std::is_trivially_assignable<T, T>::value
130 && std::is_trivially_constructible<T>::value
131 && std::is_trivially_copyable<T>::value
132 && std::is_trivially_destructible<T>::value;
133 #elif ECB_GCC_VERSION(4,4) || ECB_CLANG_VERSION(2,8)
134 return __has_trivial_assign (T)
135 && __has_trivial_constructor (T)
136 && __has_trivial_copy (T)
137 && __has_trivial_destructor (T);
138 #else
139 return 0;
140 #endif
141 }
142
143 static void construct (iterator a, size_type n = 1)
144 {
145 if (!is_simple_enough ())
146 while (n--)
147 new (a++) T ();
148 }
149
150 static void destruct (iterator a, size_type n = 1)
151 {
152 if (!is_simple_enough ())
153 while (n--)
154 (*a++).~T ();
155 }
156
157 template<class I>
158 static void cop_new (iterator a, I b) { new (a) T (*b); }
159 template<class I>
160 static void cop_set (iterator a, I b) { *a = *b ; }
161
162 // MUST copy forwards
163 template<class I>
164 static void copy (iterator dst, I src, size_type n, void (*op)(iterator, I))
165 {
166 while (n--)
167 op (dst++, src++);
168 }
169
170 static void copy (iterator dst, iterator src, size_type n, void (*op)(iterator, iterator))
171 {
172 if (is_simple_enough ())
173 memcpy (dst, src, sizeof (T) * n);
174 else
175 copy<iterator> (dst, src, n, op);
176 }
177
178 static T *alloc (size_type n) ecb_cold
179 {
180 return (T *)::operator new ((size_t) (sizeof (T) * n));
181 }
182
183 void dealloc () ecb_cold
184 {
185 destruct (buf, sze);
186 ::operator delete (buf);
187 }
188
189 size_type good_size (size_type n) ecb_cold
190 {
191 return n ? 2UL << ecb_ld32 (n) : 5;
192 }
193
194 void ins (iterator where, size_type n)
195 {
196 size_type pos = where - begin ();
197
198 if (ecb_expect_false (sze + n > res))
199 {
200 res = good_size (sze + n);
201
202 T *nbuf = alloc (res);
203 copy (nbuf, buf, sze, cop_new);
204 dealloc ();
205 buf = nbuf;
206 }
207
208 construct (buf + sze, n);
209
210 iterator src = buf + pos;
211 if (is_simple_enough ())
212 memmove (src + n, src, sizeof (T) * (sze - pos));
213 else
214 for (size_type i = sze - pos; i--; )
215 cop_set (src + n + i, src + i);
216
217 sze += n;
218 }
37 219
38public: 220public:
39 const_iterator begin () const { return &_buf[0]; }
40 iterator begin () { return &_buf[0]; }
41
42 const_iterator end () const { return &_buf[_last]; }
43 iterator end () { return &_buf[_last]; }
44
45 size_type capacity () const { return _size; } 221 size_type capacity () const { return res; }
46 size_type size () const { return _last; } 222 size_type size () const { return sze; }
223 bool empty () const { return size () == 0; }
47 224
48private: 225 size_t max_size () const
49 static T *alloc (size_type n)
50 { 226 {
51 return (T *)::operator new ((size_t) (n * sizeof (T))); 227 return (~(size_type)0) >> 1;
52 } 228 }
53 229
54 static void dealloc (T *buf) 230 const_iterator begin () const { return &buf [ 0]; }
55 { 231 iterator begin () { return &buf [ 0]; }
56 if (buf) 232 const_iterator end () const { return &buf [sze ]; }
57 ::operator delete (buf); 233 iterator end () { return &buf [sze ]; }
58 } 234 const_reference front () const { return buf [ 0]; }
235 reference front () { return buf [ 0]; }
236 const_reference back () const { return buf [sze - 1]; }
237 reference back () { return buf [sze - 1]; }
59 238
60 size_type good_size (size_type n) 239 void reserve (size_type sz)
61 { 240 {
62 return max (n, _size ? _size * 2 : 5); 241 if (ecb_expect_true (sz <= res))
63 } 242 return;
64 243
65 void reserve (iterator where, size_type n) 244 sz = good_size (sz);
245 T *nbuf = alloc (sz);
246
247 copy (nbuf, begin (), sze, cop_new);
248 dealloc ();
249
250 buf = nbuf;
251 res = sz;
252 }
253
254 void resize (size_type sz)
66 { 255 {
67 if (_last + n <= _size) 256 reserve (sz);
68 memmove (where + n, where, (end () - where) * sizeof (T)); 257
258 if (is_simple_enough ())
259 sze = sz;
69 else 260 else
70 { 261 {
71 size_type sz = _last + n; 262 while (sze < sz) construct (buf + sze++);
72 sz = good_size (sz); 263 while (sze > sz) destruct (buf + --sze);
73 T *nbuf = alloc (sz);
74
75 if (_buf)
76 {
77 memcpy (nbuf, begin (), (where - begin ()) * sizeof (T));
78 memcpy (nbuf + (where - begin ()) + n, where, (end () - where) * sizeof (T));
79 dealloc (_buf);
80 }
81
82 _buf = nbuf;
83 _size = sz;
84 } 264 }
85 } 265 }
86 266
87public:
88 void reserve (size_type sz)
89 {
90 if (_size < sz)
91 {
92 sz = good_size (sz);
93 T *nbuf = alloc (sz);
94
95 if (_buf)
96 {
97 memcpy (nbuf, begin (), size () * sizeof (T));
98 dealloc (_buf);
99 }
100
101 _buf = nbuf;
102 _size = sz;
103 }
104 }
105
106 void resize (size_type sz)
107 {
108 reserve (sz);
109 _last = sz;
110 }
111
112 simplevec () 267 simplevec ()
113 : _last(0), _size(0), _buf(0) 268 : sze(0), res(0), buf(0)
114 { 269 {
115 } 270 }
116 271
117 simplevec (size_type n, const T& t = T ()) 272 simplevec (size_type n, const T &t = T ())
118 : _last(0), _size(0), _buf(0)
119 { 273 {
120 insert (begin (), n, t); 274 sze = res = n;
275 buf = alloc (sze);
276
277 while (n--)
278 new (buf + n) T (t);
121 } 279 }
122 280
123 simplevec (const_iterator first, const_iterator last) 281 simplevec (const_iterator first, const_iterator last)
124 : _last(0), _size(0), _buf(0)
125 { 282 {
126 insert (begin (), first, last); 283 sze = res = last - first;
284 buf = alloc (sze);
285 copy (buf, first, sze, cop_new);
127 } 286 }
128 287
129 simplevec (const simplevec<T> &v) 288 simplevec (const simplevec<T> &v)
130 : _last(0), _size(0), _buf(0) 289 : sze(0), res(0), buf(0)
131 { 290 {
132 reserve (v._last); 291 sze = res = v.size ();
133 memcpy (_buf, v.begin (), v.size () * sizeof (T)); 292 buf = alloc (sze);
134 _last = v._last; 293 copy (buf, v.begin (), sze, cop_new);
294 }
295
296 ~simplevec ()
297 {
298 dealloc ();
299 }
300
301 void swap (simplevec<T> &t)
302 {
303 ::swap (sze, t.sze);
304 ::swap (res, t.res);
305 ::swap (buf, t.buf);
306 }
307
308 void clear ()
309 {
310 destruct (buf, sze);
311 sze = 0;
312 }
313
314 void push_back (const T &t)
315 {
316 reserve (sze + 1);
317 new (buf + sze++) T (t);
318 }
319
320 void pop_back ()
321 {
322 destruct (buf + --sze);
323 }
324
325 const_reference operator [](size_type idx) const { return buf[idx]; }
326 reference operator [](size_type idx) { return buf[idx]; }
327
328 const_reference at (size_type idx) const { return buf [idx]; }
329 reference at (size_type idx) { return buf [idx]; }
330
331 void assign (const_iterator first, const_iterator last)
332 {
333 simplevec<T> v (first, last);
334 swap (v);
335 }
336
337 void assign (size_type n, const T &t)
338 {
339 simplevec<T> v (n, t);
340 swap (v);
135 } 341 }
136 342
137 simplevec<T> &operator= (const simplevec<T> &v) 343 simplevec<T> &operator= (const simplevec<T> &v)
138 { 344 {
139 if (this != &v) 345 assign (v.begin (), v.end ());
140 {
141 _last = 0;
142 reserve (v._last);
143 memcpy (_buf, v.begin (), v.size () * sizeof (T));
144 _last = v._last;
145 }
146
147 return *this; 346 return *this;
148 } 347 }
149 348
150 ~simplevec ()
151 {
152 dealloc (_buf);
153 }
154
155 const T &front () const { return _buf[ 0]; }
156 T &front () { return _buf[ 0]; }
157 const T &back () const { return _buf[_last-1]; }
158 T &back () { return _buf[_last-1]; }
159
160 bool empty () const
161 {
162 return _last == 0;
163 }
164
165 void clear ()
166 {
167 _last = 0;
168 }
169
170 void push_back (const T &t)
171 {
172 reserve (_last+1);
173 *end () = t;
174 ++_last;
175 }
176
177 void push_back (T &t)
178 {
179 reserve (_last+1);
180 *end () = t;
181 ++_last;
182 }
183
184 void pop_back ()
185 {
186 --_last;
187 }
188
189 const T &operator [](size_type idx) const { return _buf[idx]; }
190 T &operator [](size_type idx) { return _buf[idx]; }
191
192 iterator insert (iterator pos, const T &t) 349 iterator insert (iterator pos, const T &t)
193 { 350 {
194 long at = pos - begin (); 351 size_type at = pos - begin ();
352
195 reserve (pos, 1); 353 ins (pos, 1);
196 pos = begin () + at; 354 buf [at] = t;
197 *pos = t; 355
198 ++_last; 356 return buf + at;
357 }
358
359 iterator insert (iterator pos, const_iterator first, const_iterator last)
360 {
361 size_type n = last - first;
362 size_type at = pos - begin ();
363
364 ins (pos, n);
365 copy (buf + at, first, n, cop_set);
366
367 return buf + at;
368 }
369
370 iterator insert (iterator pos, size_type n, const T &t)
371 {
372 size_type at = pos - begin ();
373
374 ins (pos, n);
375
376 for (iterator i = buf + at; n--; )
377 *i++ = t;
378
379 return buf + at;
380 }
381
382 iterator erase (iterator first, iterator last)
383 {
384 size_type n = last - first;
385 size_type c = end () - last;
386
387 if (is_simple_enough ())
388 memmove (first, last, sizeof (T) * c);
389 else
390 copy (first, last, c, cop_set);
391
392 sze -= n;
393 destruct (buf + sze, n);
394
395 return first;
396 }
397
398 iterator erase (iterator pos)
399 {
400 if (pos != end ())
401 erase (pos, pos + 1);
402
199 return pos; 403 return pos;
200 }
201
202 iterator insert (iterator pos, const_iterator first, const_iterator last)
203 {
204 long n = last - first;
205 long at = pos - begin ();
206
207 if (n > 0)
208 {
209 reserve (pos, n);
210 pos = begin () + at;
211 memcpy (pos, first, (last - first) * sizeof (T));
212 _last += n;
213 }
214
215 return pos;
216 }
217
218 iterator insert (iterator pos, size_type n, const T &t)
219 {
220 long at = pos - begin ();
221
222 if (n > 0)
223 {
224 reserve (pos, n);
225 pos = begin () + at;
226 for (int i = 0; i < n; ++i)
227 pos[i] = t;
228 _last += n;
229 }
230
231 return pos;
232 }
233
234 void erase (iterator first, iterator last)
235 {
236 if (last != first)
237 {
238 memmove (first, last, (end () - last) * sizeof (T));
239 _last -= last - first;
240 }
241 }
242
243 void erase (iterator pos)
244 {
245 if (pos != end ())
246 {
247 memmove (pos, pos + 1, (end () - (pos + 1)) * sizeof (T));
248 --_last;
249 }
250 }
251
252 void swap (simplevec<T> &t)
253 {
254 ::swap (_last, t._last);
255 ::swap (_size, t._size);
256 ::swap (_buf, t._buf);
257 } 404 }
258}; 405};
259 406
260template<class T> 407template<class T>
261bool operator ==(const simplevec<T> &v1, const simplevec<T> &v2) 408bool operator ==(const simplevec<T> &v1, const simplevec<T> &v2)

Diff Legend

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