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.11 by root, Sat May 19 01:56:09 2012 UTC vs.
Revision 1.29 by sf-exg, Thu Nov 13 13:58:12 2014 UTC

… …
20 return first; 20 return first;
21} 21}
22 22
23#include <new> 23#include <new>
24 24
25#if __cplusplus >= 201103L 25#if ECB_CPP11
26 #include <type_traits> 26 #include <type_traits>
27#endif 27#endif
28 28
29// original version taken from MICO, but this has been completely rewritten 29namespace estl
30// known limitations w.r.t. std::vector
31// - many methods missing
32// - no error checking, no exceptions thrown
33// - size_type is 32bit even on 64 bit hosts, so limited to 2**31 elements
34// - no allocator support
35// - we don't really care about const correctness, but we try
36// - we don't care about namespaces and stupid macros the user might define
37template<class T>
38struct simplevec
39{ 30{
40#if ESTL_BIG_VECTOR 31#if ESTL_LARGE_MEMORY_MODEL
41 // shoudl use size_t/ssize_t, but that's not portable enough for us 32 // should use size_t/ssize_t, but that's not portable enough for us
42 typedef unsigned long size_type; 33 typedef unsigned long size_type;
43 typedef long difference_type; 34 typedef long difference_type;
44#else 35#else
45 typedef uint32_t size_type; 36 typedef uint32_t size_type;
46 typedef int32_t difference_type; 37 typedef int32_t difference_type;
47#endif 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 private:
68 scoped_ptr (const scoped_ptr &);
69 scoped_ptr &operator =(const scoped_ptr &);
70 };
71
72 template<typename T>
73 struct scoped_array
74 {
75 T *p;
76
77 scoped_array () : p (0) { }
78
79 explicit
80 scoped_array (T *a) : p (a) { }
81
82 ~scoped_array ()
83 {
84 delete [] p;
85 }
86
87 void reset (T *a)
88 {
89 delete [] p;
90 p = a;
91 }
92
93 operator T *() { return p; }
94 T *get () const { return p; }
95
96 private:
97 scoped_array (const scoped_array &);
98 scoped_array &operator =(const scoped_array &);
99 };
100}
101
102// original version taken from MICO, but this has been completely rewritten
103// known limitations w.r.t. std::vector
104// - many methods missing
105// - no error checking, no exceptions thrown (e.g. at())
106// - size_type is 32bit even on 64 bit hosts, so limited to 2**31 elements
107// - no allocator support
108// - we don't really care about const correctness, but we try
109// - we don't care about namespaces and stupid macros the user might define
110// - no bool specialisation
111template<class T>
112struct simplevec
113{
114 typedef estl::size_type size_type;
48 115
49 typedef T value_type; 116 typedef T value_type;
50 typedef T *iterator; 117 typedef T *iterator;
51 typedef const T *const_iterator; 118 typedef const T *const_iterator;
52 typedef T *pointer; 119 typedef T *pointer;
… …
62 129
63 // we shamelessly optimise for "simple" types. everything 130 // we shamelessly optimise for "simple" types. everything
64 // "not simple enough" will use the slow path. 131 // "not simple enough" will use the slow path.
65 static bool is_simple_enough () 132 static bool is_simple_enough ()
66 { 133 {
67 return 1; // we are not there yet 134 #if ECB_CPP11
68 #if __cplusplus >= 201103L
69 return std::is_trivially_assignable<T, T>::value 135 return std::is_trivially_assignable<T, T>::value
70 && std::is_trivially_constructable<T>::value 136 && std::is_trivially_constructible<T>::value
71 && std::is_trivially_copyable<T>::value 137 && std::is_trivially_copyable<T>::value
72 && std::is_trivially_destructible<T>::value; 138 && std::is_trivially_destructible<T>::value;
73 #elif ECB_GCC_VERSION(4,4) 139 #elif ECB_GCC_VERSION(4,4) || ECB_CLANG_VERSION(2,8)
74 return __has_trivial_assign (T) 140 return __has_trivial_assign (T)
75 && __has_trivial_constructor (T) 141 && __has_trivial_constructor (T)
76 && __has_trivial_copy (T) 142 && __has_trivial_copy (T)
77 && __has_trivial_destructor (T); 143 && __has_trivial_destructor (T);
78 #else 144 #else
… …
82 148
83 static void construct (iterator a, size_type n = 1) 149 static void construct (iterator a, size_type n = 1)
84 { 150 {
85 if (!is_simple_enough ()) 151 if (!is_simple_enough ())
86 while (n--) 152 while (n--)
87 new (*a++) T (); 153 new (a++) T ();
88 } 154 }
89 155
90 static void destruct (iterator a, size_type n = 1) 156 static void destruct (iterator a, size_type n = 1)
91 { 157 {
92 if (!is_simple_enough ()) 158 if (!is_simple_enough ())
… …
97 template<class I> 163 template<class I>
98 static void cop_new (iterator a, I b) { new (a) T (*b); } 164 static void cop_new (iterator a, I b) { new (a) T (*b); }
99 template<class I> 165 template<class I>
100 static void cop_set (iterator a, I b) { *a = *b ; } 166 static void cop_set (iterator a, I b) { *a = *b ; }
101 167
168 // MUST copy forwards
102 template<class I> 169 template<class I>
103 static void copy_lower (iterator dst, I src, size_type n, void (*op)(iterator, I ) = cop_new) 170 static void copy (iterator dst, I src, size_type n, void (*op)(iterator, I))
104 { 171 {
105 while (n--) 172 while (n--)
106 op (dst++, src++); 173 op (dst++, src++);
107 } 174 }
108 175
109 static void copy_lower (iterator dst, iterator src, size_type n, void (*op)(iterator, iterator) = cop_new)
110 {
111 if (is_simple_enough ())
112 memmove (dst, src, sizeof (T) * n);
113 else
114 copy_lower<iterator> (dst, src, n, cop_new);
115 }
116
117 static void copy_higher (iterator dst, iterator src, size_type n, void (*op)(iterator, iterator) = cop_new)
118 {
119 if (is_simple_enough ())
120 memmove (dst, src, sizeof (T) * n);
121 else
122 while (n--)
123 op (dst + n, src + n);
124 }
125
126 template<class I>
127 static void copy (iterator dst, I src, size_type n, void (*op)(iterator, I) = cop_new)
128 {
129 copy_lower<I> (dst, src, n, op);
130 }
131
132 static void copy (iterator dst, iterator src, size_type n, void (*op)(iterator, iterator) = cop_new) 176 static void copy (iterator dst, iterator src, size_type n, void (*op)(iterator, iterator))
133 { 177 {
134 if (is_simple_enough ()) 178 if (is_simple_enough ())
135 memcpy (dst, src, sizeof (T) * n); 179 memcpy (dst, src, sizeof (T) * n);
136 else 180 else
137 copy<iterator> (dst, src, n, op); 181 copy<iterator> (dst, src, n, op);
… …
166 dealloc (); 210 dealloc ();
167 buf = nbuf; 211 buf = nbuf;
168 } 212 }
169 213
170 construct (buf + sze, n); 214 construct (buf + sze, n);
171 copy_higher (buf + pos + n, buf + pos, sze - pos, cop_set); 215
216 iterator src = buf + pos;
217 if (is_simple_enough ())
218 memmove (src + n, src, sizeof (T) * (sze - pos));
219 else
220 for (size_type i = sze - pos; i--; )
221 cop_set (src + n + i, src + i);
222
172 sze += n; 223 sze += n;
173 } 224 }
174 225
175public: 226public:
176 size_type capacity () const { return res; } 227 size_type capacity () const { return res; }
… …
197 return; 248 return;
198 249
199 sz = good_size (sz); 250 sz = good_size (sz);
200 T *nbuf = alloc (sz); 251 T *nbuf = alloc (sz);
201 252
202 copy (nbuf, begin (), sze); 253 copy (nbuf, begin (), sze, cop_new);
203 dealloc (); 254 dealloc ();
204 255
205 buf = nbuf; 256 buf = nbuf;
206 res = sz; 257 res = sz;
207 } 258 }
… …
231 282
232 while (n--) 283 while (n--)
233 new (buf + n) T (t); 284 new (buf + n) T (t);
234 } 285 }
235 286
236 template<class I> 287 simplevec (const_iterator first, const_iterator last)
237 simplevec (I first, I last)
238 { 288 {
239 sze = res = last - first; 289 sze = res = last - first;
240 buf = alloc (sze); 290 buf = alloc (sze);
241 copy (buf, first, sze); 291 copy (buf, first, sze, cop_new);
242 } 292 }
243 293
244 simplevec (const simplevec<T> &v) 294 simplevec (const simplevec<T> &v)
245 : sze(0), res(0), buf(0) 295 : sze(0), res(0), buf(0)
246 { 296 {
247 sze = res = v.size (); 297 sze = res = v.size ();
248 buf = alloc (sze); 298 buf = alloc (sze);
249 copy (buf, v.begin (), sze); 299 copy (buf, v.begin (), sze, cop_new);
250 } 300 }
251 301
252 ~simplevec () 302 ~simplevec ()
253 { 303 {
254 dealloc (); 304 dealloc ();
… …
282 reference operator [](size_type idx) { return buf[idx]; } 332 reference operator [](size_type idx) { return buf[idx]; }
283 333
284 const_reference at (size_type idx) const { return buf [idx]; } 334 const_reference at (size_type idx) const { return buf [idx]; }
285 reference at (size_type idx) { return buf [idx]; } 335 reference at (size_type idx) { return buf [idx]; }
286 336
287 template<class I> 337 void assign (const_iterator first, const_iterator last)
288 void assign (I first, I last)
289 { 338 {
290 swap (simplevec<T> (first, last)); 339 simplevec<T> v (first, last);
340 swap (v);
291 } 341 }
292 342
293 void assign (size_type n, const T &t) 343 void assign (size_type n, const T &t)
294 { 344 {
295 swap (simplevec<T> (n, t)); 345 simplevec<T> v (n, t);
346 swap (v);
296 } 347 }
297 348
298 simplevec<T> &operator= (const simplevec<T> &v) 349 simplevec<T> &operator= (const simplevec<T> &v)
299 { 350 {
300 assign (v.begin (), v.end ()); 351 assign (v.begin (), v.end ());
… …
309 buf [at] = t; 360 buf [at] = t;
310 361
311 return buf + at; 362 return buf + at;
312 } 363 }
313 364
314 template<class I>
315 iterator insert (iterator pos, I first, I last) 365 iterator insert (iterator pos, const_iterator first, const_iterator last)
316 { 366 {
317 size_type n = last - first; 367 size_type n = last - first;
318 size_type at = pos - begin (); 368 size_type at = pos - begin ();
319 369
320 ins (pos, n); 370 ins (pos, n);
… …
333 *i++ = t; 383 *i++ = t;
334 384
335 return buf + at; 385 return buf + at;
336 } 386 }
337 387
338 void erase (iterator first, iterator last) 388 iterator erase (iterator first, iterator last)
339 { 389 {
340 size_t n = last - first; 390 size_type n = last - first;
391 size_type c = end () - last;
341 392
342 copy_lower (last, first, end () - last, cop_set); 393 if (is_simple_enough ())
394 memmove (first, last, sizeof (T) * c);
395 else
396 copy (first, last, c, cop_set);
397
343 sze -= n; 398 sze -= n;
344 destruct (buf + sze, n); 399 destruct (buf + sze, n);
345 }
346 400
401 return first;
402 }
403
347 void erase (iterator pos) 404 iterator erase (iterator pos)
348 { 405 {
349 if (pos != end ()) 406 if (pos != end ())
350 erase (pos, pos + 1); 407 erase (pos, pos + 1);
408
409 return pos;
351 } 410 }
352}; 411};
353 412
354template<class T> 413template<class T>
355bool operator ==(const simplevec<T> &v1, const simplevec<T> &v2) 414bool operator ==(const simplevec<T> &v1, const simplevec<T> &v2)

Diff Legend

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