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.12 by root, Sat May 19 01:57:09 2012 UTC vs.
Revision 1.26 by sf-exg, Thu Nov 6 18:13:31 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 29// original version taken from MICO, but this has been completely rewritten
30// known limitations w.r.t. std::vector 30// known limitations w.r.t. std::vector
… …
37// - no bool specialisation 37// - no bool specialisation
38template<class T> 38template<class T>
39struct simplevec 39struct simplevec
40{ 40{
41#if ESTL_BIG_VECTOR 41#if ESTL_BIG_VECTOR
42 // shoudl use size_t/ssize_t, but that's not portable enough for us 42 // should use size_t/ssize_t, but that's not portable enough for us
43 typedef unsigned long size_type; 43 typedef unsigned long size_type;
44 typedef long difference_type; 44 typedef long difference_type;
45#else 45#else
46 typedef uint32_t size_type; 46 typedef uint32_t size_type;
47 typedef int32_t difference_type; 47 typedef int32_t difference_type;
… …
63 63
64 // we shamelessly optimise for "simple" types. everything 64 // we shamelessly optimise for "simple" types. everything
65 // "not simple enough" will use the slow path. 65 // "not simple enough" will use the slow path.
66 static bool is_simple_enough () 66 static bool is_simple_enough ()
67 { 67 {
68 return 1; // we are not there yet 68 #if ECB_CPP11
69 #if __cplusplus >= 201103L
70 return std::is_trivially_assignable<T, T>::value 69 return std::is_trivially_assignable<T, T>::value
71 && std::is_trivially_constructable<T>::value 70 && std::is_trivially_constructible<T>::value
72 && std::is_trivially_copyable<T>::value 71 && std::is_trivially_copyable<T>::value
73 && std::is_trivially_destructible<T>::value; 72 && std::is_trivially_destructible<T>::value;
74 #elif ECB_GCC_VERSION(4,4) 73 #elif ECB_GCC_VERSION(4,4)
75 return __has_trivial_assign (T) 74 return __has_trivial_assign (T)
76 && __has_trivial_constructor (T) 75 && __has_trivial_constructor (T)
… …
83 82
84 static void construct (iterator a, size_type n = 1) 83 static void construct (iterator a, size_type n = 1)
85 { 84 {
86 if (!is_simple_enough ()) 85 if (!is_simple_enough ())
87 while (n--) 86 while (n--)
88 new (*a++) T (); 87 new (a++) T ();
89 } 88 }
90 89
91 static void destruct (iterator a, size_type n = 1) 90 static void destruct (iterator a, size_type n = 1)
92 { 91 {
93 if (!is_simple_enough ()) 92 if (!is_simple_enough ())
… …
98 template<class I> 97 template<class I>
99 static void cop_new (iterator a, I b) { new (a) T (*b); } 98 static void cop_new (iterator a, I b) { new (a) T (*b); }
100 template<class I> 99 template<class I>
101 static void cop_set (iterator a, I b) { *a = *b ; } 100 static void cop_set (iterator a, I b) { *a = *b ; }
102 101
102 // MUST copy forwards
103 template<class I> 103 template<class I>
104 static void copy_lower (iterator dst, I src, size_type n, void (*op)(iterator, I ) = cop_new) 104 static void copy (iterator dst, I src, size_type n, void (*op)(iterator, I))
105 { 105 {
106 while (n--) 106 while (n--)
107 op (dst++, src++); 107 op (dst++, src++);
108 } 108 }
109 109
110 static void copy_lower (iterator dst, iterator src, size_type n, void (*op)(iterator, iterator) = cop_new)
111 {
112 if (is_simple_enough ())
113 memmove (dst, src, sizeof (T) * n);
114 else
115 copy_lower<iterator> (dst, src, n, cop_new);
116 }
117
118 static void copy_higher (iterator dst, iterator src, size_type n, void (*op)(iterator, iterator) = cop_new)
119 {
120 if (is_simple_enough ())
121 memmove (dst, src, sizeof (T) * n);
122 else
123 while (n--)
124 op (dst + n, src + n);
125 }
126
127 template<class I>
128 static void copy (iterator dst, I src, size_type n, void (*op)(iterator, I) = cop_new)
129 {
130 copy_lower<I> (dst, src, n, op);
131 }
132
133 static void copy (iterator dst, iterator src, size_type n, void (*op)(iterator, iterator) = cop_new) 110 static void copy (iterator dst, iterator src, size_type n, void (*op)(iterator, iterator))
134 { 111 {
135 if (is_simple_enough ()) 112 if (is_simple_enough ())
136 memcpy (dst, src, sizeof (T) * n); 113 memcpy (dst, src, sizeof (T) * n);
137 else 114 else
138 copy<iterator> (dst, src, n, op); 115 copy<iterator> (dst, src, n, op);
… …
167 dealloc (); 144 dealloc ();
168 buf = nbuf; 145 buf = nbuf;
169 } 146 }
170 147
171 construct (buf + sze, n); 148 construct (buf + sze, n);
172 copy_higher (buf + pos + n, buf + pos, sze - pos, cop_set); 149
150 iterator src = buf + pos;
151 if (is_simple_enough ())
152 memmove (src + n, src, sizeof (T) * (sze - pos));
153 else
154 for (size_type i = sze - pos; i--; )
155 cop_set (src + n + i, src + i);
156
173 sze += n; 157 sze += n;
174 } 158 }
175 159
176public: 160public:
177 size_type capacity () const { return res; } 161 size_type capacity () const { return res; }
… …
198 return; 182 return;
199 183
200 sz = good_size (sz); 184 sz = good_size (sz);
201 T *nbuf = alloc (sz); 185 T *nbuf = alloc (sz);
202 186
203 copy (nbuf, begin (), sze); 187 copy (nbuf, begin (), sze, cop_new);
204 dealloc (); 188 dealloc ();
205 189
206 buf = nbuf; 190 buf = nbuf;
207 res = sz; 191 res = sz;
208 } 192 }
… …
232 216
233 while (n--) 217 while (n--)
234 new (buf + n) T (t); 218 new (buf + n) T (t);
235 } 219 }
236 220
237 template<class I> 221 simplevec (const_iterator first, const_iterator last)
238 simplevec (I first, I last)
239 { 222 {
240 sze = res = last - first; 223 sze = res = last - first;
241 buf = alloc (sze); 224 buf = alloc (sze);
242 copy (buf, first, sze); 225 copy (buf, first, sze, cop_new);
243 } 226 }
244 227
245 simplevec (const simplevec<T> &v) 228 simplevec (const simplevec<T> &v)
246 : sze(0), res(0), buf(0) 229 : sze(0), res(0), buf(0)
247 { 230 {
248 sze = res = v.size (); 231 sze = res = v.size ();
249 buf = alloc (sze); 232 buf = alloc (sze);
250 copy (buf, v.begin (), sze); 233 copy (buf, v.begin (), sze, cop_new);
251 } 234 }
252 235
253 ~simplevec () 236 ~simplevec ()
254 { 237 {
255 dealloc (); 238 dealloc ();
… …
283 reference operator [](size_type idx) { return buf[idx]; } 266 reference operator [](size_type idx) { return buf[idx]; }
284 267
285 const_reference at (size_type idx) const { return buf [idx]; } 268 const_reference at (size_type idx) const { return buf [idx]; }
286 reference at (size_type idx) { return buf [idx]; } 269 reference at (size_type idx) { return buf [idx]; }
287 270
288 template<class I> 271 void assign (const_iterator first, const_iterator last)
289 void assign (I first, I last)
290 { 272 {
291 swap (simplevec<T> (first, last)); 273 simplevec<T> v (first, last);
274 swap (v);
292 } 275 }
293 276
294 void assign (size_type n, const T &t) 277 void assign (size_type n, const T &t)
295 { 278 {
296 swap (simplevec<T> (n, t)); 279 simplevec<T> v (n, t);
280 swap (v);
297 } 281 }
298 282
299 simplevec<T> &operator= (const simplevec<T> &v) 283 simplevec<T> &operator= (const simplevec<T> &v)
300 { 284 {
301 assign (v.begin (), v.end ()); 285 assign (v.begin (), v.end ());
… …
310 buf [at] = t; 294 buf [at] = t;
311 295
312 return buf + at; 296 return buf + at;
313 } 297 }
314 298
315 template<class I>
316 iterator insert (iterator pos, I first, I last) 299 iterator insert (iterator pos, const_iterator first, const_iterator last)
317 { 300 {
318 size_type n = last - first; 301 size_type n = last - first;
319 size_type at = pos - begin (); 302 size_type at = pos - begin ();
320 303
321 ins (pos, n); 304 ins (pos, n);
… …
334 *i++ = t; 317 *i++ = t;
335 318
336 return buf + at; 319 return buf + at;
337 } 320 }
338 321
339 void erase (iterator first, iterator last) 322 iterator erase (iterator first, iterator last)
340 { 323 {
341 size_t n = last - first; 324 size_type n = last - first;
325 size_type c = end () - last;
342 326
343 copy_lower (last, first, end () - last, cop_set); 327 if (is_simple_enough ())
328 memmove (first, last, sizeof (T) * c);
329 else
330 copy (first, last, c, cop_set);
331
344 sze -= n; 332 sze -= n;
345 destruct (buf + sze, n); 333 destruct (buf + sze, n);
346 }
347 334
335 return first;
336 }
337
348 void erase (iterator pos) 338 iterator erase (iterator pos)
349 { 339 {
350 if (pos != end ()) 340 if (pos != end ())
351 erase (pos, pos + 1); 341 erase (pos, pos + 1);
342
343 return pos;
352 } 344 }
353}; 345};
354 346
355template<class T> 347template<class T>
356bool operator ==(const simplevec<T> &v1, const simplevec<T> &v2) 348bool operator ==(const simplevec<T> &v1, const simplevec<T> &v2)

Diff Legend

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