Mercurial > projects > qtd
annotate qt/core/QList.d @ 296:5173835bb372 signals
iteration over QList with opApply
| author | eldar |
|---|---|
| date | Sun, 22 Nov 2009 20:43:10 +0000 |
| parents | 463563fc9e17 |
| children | bc783e20da2b |
| rev | line source |
|---|---|
| 291 | 1 module qt.core.QList; |
| 2 | |
| 3 import qt.QGlobal; | |
| 293 | 4 import qt.QtdObject; |
| 291 | 5 import qt.qtd.Atomic; |
| 293 | 6 import qt.qtd.MetaMarshall; |
|
295
463563fc9e17
more of QList. const functions in C++ are now const in D too. Drop of the store result feature, which was incompatible with const functions and introduced too much of the bloat in the generator.
eldar
parents:
294
diff
changeset
|
7 import qt.core.QTypeInfo; |
| 296 | 8 import qt.core.QString; |
| 292 | 9 |
| 291 | 10 import core.stdc.stdlib : qRealloc = realloc, qFree = free, qMalloc = malloc; |
| 11 import core.stdc.string : memcpy, memmove; | |
| 12 | |
| 292 | 13 import std.traits; |
| 14 | |
| 291 | 15 enum INT_MAX = int.max; |
| 16 | |
| 292 | 17 bool isComplex(T)() |
| 293 | 18 if (is(T.QTypeInfo)) |
| 292 | 19 { |
| 293 | 20 return T.QTypeInfo.isComplex; |
| 292 | 21 } |
| 22 | |
| 23 bool isStatic(T)() | |
| 293 | 24 if (is(T.QTypeInfo)) |
| 292 | 25 { |
| 293 | 26 return T.QTypeInfo.isStatic; |
| 292 | 27 } |
| 28 | |
| 29 bool isLarge(T)() | |
| 293 | 30 if (is(T.QTypeInfo)) |
| 292 | 31 { |
| 293 | 32 return T.QTypeInfo.isLarge; |
| 292 | 33 } |
| 34 | |
| 296 | 35 template isQtReference(T) |
| 36 { | |
| 37 enum isQtReference = isQObjectType!T || isObjectType!T || isValueType!T || is(T == string); | |
| 38 } | |
| 39 | |
| 291 | 40 int qAllocMore(int alloc, int extra) |
| 41 { | |
| 42 if (alloc == 0 && extra == 0) | |
| 43 return 0; | |
| 44 const int page = 1 << 12; | |
| 45 int nalloc; | |
| 46 alloc += extra; | |
| 47 if (alloc < 1<<6) { | |
| 48 nalloc = (1<<3) + ((alloc >>3) << 3); | |
| 49 } else { | |
| 50 // don't do anything if the loop will overflow signed int. | |
| 51 if (alloc >= INT_MAX/2) | |
| 52 return INT_MAX; | |
| 53 nalloc = (alloc < page) ? 1 << 3 : page; | |
| 54 while (nalloc < alloc) { | |
| 55 if (nalloc <= 0) | |
| 56 return INT_MAX; | |
| 57 nalloc *= 2; | |
| 58 } | |
| 59 } | |
| 60 return nalloc - extra; | |
| 61 } | |
| 62 | |
|
295
463563fc9e17
more of QList. const functions in C++ are now const in D too. Drop of the store result feature, which was incompatible with const functions and introduced too much of the bloat in the generator.
eldar
parents:
294
diff
changeset
|
63 void q_new_at(T)(T* ptr, const ref T t) |
|
463563fc9e17
more of QList. const functions in C++ are now const in D too. Drop of the store result feature, which was incompatible with const functions and introduced too much of the bloat in the generator.
eldar
parents:
294
diff
changeset
|
64 { |
|
463563fc9e17
more of QList. const functions in C++ are now const in D too. Drop of the store result feature, which was incompatible with const functions and introduced too much of the bloat in the generator.
eldar
parents:
294
diff
changeset
|
65 memcpy(ptr, &t, T.sizeof); |
|
463563fc9e17
more of QList. const functions in C++ are now const in D too. Drop of the store result feature, which was incompatible with const functions and introduced too much of the bloat in the generator.
eldar
parents:
294
diff
changeset
|
66 /* static if (__traits(compiles, ptr.__postblit())) DMD bug #3539 |
|
463563fc9e17
more of QList. const functions in C++ are now const in D too. Drop of the store result feature, which was incompatible with const functions and introduced too much of the bloat in the generator.
eldar
parents:
294
diff
changeset
|
67 ptr.__postblit();*/ |
|
463563fc9e17
more of QList. const functions in C++ are now const in D too. Drop of the store result feature, which was incompatible with const functions and introduced too much of the bloat in the generator.
eldar
parents:
294
diff
changeset
|
68 } |
|
463563fc9e17
more of QList. const functions in C++ are now const in D too. Drop of the store result feature, which was incompatible with const functions and introduced too much of the bloat in the generator.
eldar
parents:
294
diff
changeset
|
69 |
|
463563fc9e17
more of QList. const functions in C++ are now const in D too. Drop of the store result feature, which was incompatible with const functions and introduced too much of the bloat in the generator.
eldar
parents:
294
diff
changeset
|
70 T* q_new(T)(const ref T t) |
|
463563fc9e17
more of QList. const functions in C++ are now const in D too. Drop of the store result feature, which was incompatible with const functions and introduced too much of the bloat in the generator.
eldar
parents:
294
diff
changeset
|
71 { |
|
463563fc9e17
more of QList. const functions in C++ are now const in D too. Drop of the store result feature, which was incompatible with const functions and introduced too much of the bloat in the generator.
eldar
parents:
294
diff
changeset
|
72 T* ptr = cast(T*) qMalloc(T.sizeof); |
|
463563fc9e17
more of QList. const functions in C++ are now const in D too. Drop of the store result feature, which was incompatible with const functions and introduced too much of the bloat in the generator.
eldar
parents:
294
diff
changeset
|
73 q_new_at!T(ptr, t); |
|
463563fc9e17
more of QList. const functions in C++ are now const in D too. Drop of the store result feature, which was incompatible with const functions and introduced too much of the bloat in the generator.
eldar
parents:
294
diff
changeset
|
74 return ptr; |
|
463563fc9e17
more of QList. const functions in C++ are now const in D too. Drop of the store result feature, which was incompatible with const functions and introduced too much of the bloat in the generator.
eldar
parents:
294
diff
changeset
|
75 } |
|
463563fc9e17
more of QList. const functions in C++ are now const in D too. Drop of the store result feature, which was incompatible with const functions and introduced too much of the bloat in the generator.
eldar
parents:
294
diff
changeset
|
76 |
|
463563fc9e17
more of QList. const functions in C++ are now const in D too. Drop of the store result feature, which was incompatible with const functions and introduced too much of the bloat in the generator.
eldar
parents:
294
diff
changeset
|
77 void q_delete(T)(T* t) |
|
463563fc9e17
more of QList. const functions in C++ are now const in D too. Drop of the store result feature, which was incompatible with const functions and introduced too much of the bloat in the generator.
eldar
parents:
294
diff
changeset
|
78 { |
|
463563fc9e17
more of QList. const functions in C++ are now const in D too. Drop of the store result feature, which was incompatible with const functions and introduced too much of the bloat in the generator.
eldar
parents:
294
diff
changeset
|
79 static if (__traits(compiles, t.__dtor())) |
|
463563fc9e17
more of QList. const functions in C++ are now const in D too. Drop of the store result feature, which was incompatible with const functions and introduced too much of the bloat in the generator.
eldar
parents:
294
diff
changeset
|
80 t.__dtor(); |
|
463563fc9e17
more of QList. const functions in C++ are now const in D too. Drop of the store result feature, which was incompatible with const functions and introduced too much of the bloat in the generator.
eldar
parents:
294
diff
changeset
|
81 qFree(t); |
|
463563fc9e17
more of QList. const functions in C++ are now const in D too. Drop of the store result feature, which was incompatible with const functions and introduced too much of the bloat in the generator.
eldar
parents:
294
diff
changeset
|
82 } |
|
463563fc9e17
more of QList. const functions in C++ are now const in D too. Drop of the store result feature, which was incompatible with const functions and introduced too much of the bloat in the generator.
eldar
parents:
294
diff
changeset
|
83 |
| 291 | 84 private int grow(int size) |
| 85 { | |
| 86 // dear compiler: don't optimize me out. | |
| 292 | 87 // synchronized { |
| 291 | 88 int x = qAllocMore(size * (void*).sizeof, QListData.DataHeaderSize) / (void*).sizeof; |
| 89 return x; | |
| 292 | 90 // } |
| 291 | 91 } |
| 92 | |
| 93 struct QListData { | |
| 94 struct Data { | |
| 95 Atomic!int ref_; | |
| 96 int alloc, begin, end; | |
| 97 uint sharable; | |
| 98 void*[1] array; | |
| 99 } | |
| 100 | |
| 101 enum { DataHeaderSize = Data.sizeof - (void*).sizeof } | |
| 102 | |
| 103 static Data shared_null; | |
| 104 Data *d; | |
| 105 | |
| 106 static this() | |
| 107 { | |
| 108 shared_null = Data(Atomic!int(1), 0, 0, 0, true, [null]); | |
| 109 } | |
| 110 | |
| 111 | |
| 112 // Data *detach(); // remove in 5.0 | |
| 113 | |
| 114 Data* detach2() | |
| 115 { | |
| 116 Data* x = d; | |
| 117 d = cast(Data*)(qMalloc(DataHeaderSize + x.alloc * (void*).sizeof)); | |
| 118 if (!d) | |
| 119 qFatal("QList: Out of memory"); | |
| 120 | |
| 121 memcpy(d, x, DataHeaderSize + x.alloc * (void*).sizeof); | |
| 122 d.alloc = x.alloc; | |
| 123 d.ref_.store(1); | |
| 124 d.sharable = true; | |
| 125 if (!d.alloc) | |
| 126 d.begin = d.end = 0; | |
| 127 | |
| 128 return x; | |
| 129 } | |
| 130 | |
| 131 void realloc(int alloc) | |
| 132 { | |
| 133 // assert(d.ref_ == 1); | |
| 134 Data* x = cast(Data*)(qRealloc(d, DataHeaderSize + alloc * (void*).sizeof)); | |
| 135 if (!x) | |
| 136 qFatal("QList: Out of memory"); | |
| 137 | |
| 138 d = x; | |
| 139 d.alloc = alloc; | |
| 140 if (!alloc) | |
| 141 d.begin = d.end = 0; | |
| 142 } | |
| 143 | |
| 144 void** append() | |
| 145 { | |
| 146 // #TODO Q_ASSERT(d.ref_ == 1); | |
| 147 if (d.end == d.alloc) { | |
| 148 int n = d.end - d.begin; | |
| 149 if (d.begin > 2 * d.alloc / 3) { | |
| 150 memcpy(d.array.ptr + n, d.array.ptr + d.begin, n * (void*).sizeof); | |
| 151 d.begin = n; | |
| 152 d.end = n * 2; | |
| 153 } else { | |
| 154 realloc(grow(d.alloc + 1)); | |
| 155 } | |
| 156 } | |
| 157 return d.array.ptr + d.end++; | |
| 158 } | |
| 159 | |
| 160 void **append(const ref QListData l) | |
| 161 { | |
| 162 // Q_ASSERT(d.ref_ == 1); | |
| 163 int e = d.end; | |
| 164 int n = l.d.end - l.d.begin; | |
| 165 if (n) { | |
| 166 if (e + n > d.alloc) | |
| 167 realloc(grow(e + l.d.end - l.d.begin)); | |
| 168 memcpy(d.array.ptr + d.end, l.d.array.ptr + l.d.begin, n * (void*).sizeof); | |
| 169 d.end += n; | |
| 170 } | |
| 171 return d.array.ptr + e; | |
| 172 } | |
| 173 | |
| 174 void **prepend() | |
| 175 { | |
| 176 // Q_ASSERT(d.ref_ == 1); | |
| 177 if (d.begin == 0) { | |
| 178 if (d.end >= d.alloc / 3) | |
| 179 realloc(grow(d.alloc + 1)); | |
| 180 | |
| 181 if (d.end < d.alloc / 3) | |
| 182 d.begin = d.alloc - 2 * d.end; | |
| 183 else | |
| 184 d.begin = d.alloc - d.end; | |
| 185 | |
| 186 memmove(d.array.ptr + d.begin, d.array.ptr, d.end * (void*).sizeof); | |
| 187 d.end += d.begin; | |
| 188 } | |
| 189 return d.array.ptr + --d.begin; | |
| 190 } | |
| 191 | |
| 192 void **insert(int i) | |
| 193 { | |
| 194 // Q_ASSERT(d.ref_ == 1); | |
| 195 if (i <= 0) | |
| 196 return prepend(); | |
| 197 if (i >= d.end - d.begin) | |
| 198 return append(); | |
| 199 | |
| 200 bool leftward = false; | |
| 201 int size = d.end - d.begin; | |
| 202 | |
| 203 if (d.begin == 0) { | |
| 204 if (d.end == d.alloc) { | |
| 205 // If the array is full, we expand it and move some items rightward | |
| 206 realloc(grow(d.alloc + 1)); | |
| 207 } else { | |
| 208 // If there is free space at the end of the array, we move some items rightward | |
| 209 } | |
| 210 } else { | |
| 211 if (d.end == d.alloc) { | |
| 212 // If there is free space at the beginning of the array, we move some items leftward | |
| 213 leftward = true; | |
| 214 } else { | |
| 215 // If there is free space at both ends, we move as few items as possible | |
| 216 leftward = (i < size - i); | |
| 217 } | |
| 218 } | |
| 219 | |
| 220 if (leftward) { | |
| 221 --d.begin; | |
| 222 memmove(d.array.ptr + d.begin, d.array.ptr + d.begin + 1, i * (void*).sizeof); | |
| 223 } else { | |
| 224 memmove(d.array.ptr + d.begin + i + 1, d.array.ptr + d.begin + i, | |
| 225 (size - i) * (void*).sizeof); | |
| 226 ++d.end; | |
| 227 } | |
| 228 return d.array.ptr + d.begin + i; | |
| 229 } | |
| 230 | |
| 231 void remove(int i) | |
| 232 { | |
| 233 // Q_ASSERT(d.ref_ == 1); | |
| 234 i += d.begin; | |
| 235 if (i - d.begin < d.end - i) { | |
| 236 if (int offset = i - d.begin) | |
| 237 memmove(d.array.ptr + d.begin + 1, d.array.ptr + d.begin, offset * (void*).sizeof); | |
| 238 d.begin++; | |
| 239 } else { | |
| 240 if (int offset = d.end - i - 1) | |
| 241 memmove(d.array.ptr + i, d.array.ptr + i + 1, offset * (void*).sizeof); | |
| 242 d.end--; | |
| 243 } | |
| 244 } | |
| 245 | |
| 246 void remove(int i, int n) | |
| 247 { | |
| 248 // Q_ASSERT(d.ref_ == 1); | |
| 249 i += d.begin; | |
| 250 int middle = i + n/2; | |
| 251 if (middle - d.begin < d.end - middle) { | |
| 252 memmove(d.array.ptr + d.begin + n, d.array.ptr + d.begin, | |
| 253 (i - d.begin) * (void*).sizeof); | |
| 254 d.begin += n; | |
| 255 } else { | |
| 256 memmove(d.array.ptr + i, d.array.ptr + i + n, | |
| 257 (d.end - i - n) * (void*).sizeof); | |
| 258 d.end -= n; | |
| 259 } | |
| 260 } | |
| 261 | |
| 262 void move(int from, int to) | |
| 263 { | |
| 264 // Q_ASSERT(d.ref_ == 1); | |
| 265 if (from == to) | |
| 266 return; | |
| 267 | |
| 268 from += d.begin; | |
| 269 to += d.begin; | |
| 270 void *t = d.array.ptr[from]; | |
| 271 | |
| 272 if (from < to) { | |
| 273 if (d.end == d.alloc || 3 * (to - from) < 2 * (d.end - d.begin)) { | |
| 274 memmove(d.array.ptr + from, d.array.ptr + from + 1, (to - from) * (void*).sizeof); | |
| 275 } else { | |
| 276 // optimization | |
| 277 if (int offset = from - d.begin) | |
| 278 memmove(d.array.ptr + d.begin + 1, d.array.ptr + d.begin, offset * (void*).sizeof); | |
| 279 if (int offset = d.end - (to + 1)) | |
| 280 memmove(d.array.ptr + to + 2, d.array.ptr + to + 1, offset * (void*).sizeof); | |
| 281 ++d.begin; | |
| 282 ++d.end; | |
| 283 ++to; | |
| 284 } | |
| 285 } else { | |
| 286 if (d.begin == 0 || 3 * (from - to) < 2 * (d.end - d.begin)) { | |
| 287 memmove(d.array.ptr + to + 1, d.array.ptr + to, (from - to) * (void*).sizeof); | |
| 288 } else { | |
| 289 // optimization | |
| 290 if (int offset = to - d.begin) | |
| 291 memmove(d.array.ptr + d.begin - 1, d.array.ptr + d.begin, offset * (void*).sizeof); | |
| 292 if (int offset = d.end - (from + 1)) | |
| 293 memmove(d.array.ptr + from, d.array.ptr + from + 1, offset * (void*).sizeof); | |
| 294 --d.begin; | |
| 295 --d.end; | |
| 296 --to; | |
| 297 } | |
| 298 } | |
| 299 d.array.ptr[to] = t; | |
| 300 } | |
| 301 | |
| 302 void **erase(void **xi) | |
| 303 { | |
| 304 // Q_ASSERT(d.ref_ == 1); | |
| 305 int i = xi - (d.array.ptr + d.begin); | |
| 306 remove(i); | |
| 307 return d.array.ptr + d.begin + i; | |
| 308 } | |
| 309 | |
| 310 int size() const { return d.end - d.begin; } | |
| 311 bool isEmpty() const { return d.end == d.begin; } | |
| 312 const (void*)* at(int i) const { return d.array.ptr + d.begin + i; } | |
| 313 const (void*)* begin() const { return d.array.ptr + d.begin; } | |
| 314 const (void*)* end() const { return d.array.ptr + d.end; } | |
| 315 } | |
| 316 | |
| 317 import std.stdio; | |
| 318 | |
|
295
463563fc9e17
more of QList. const functions in C++ are now const in D too. Drop of the store result feature, which was incompatible with const functions and introduced too much of the bloat in the generator.
eldar
parents:
294
diff
changeset
|
319 alias void Dummy; // DMD bug #3538 |
|
463563fc9e17
more of QList. const functions in C++ are now const in D too. Drop of the store result feature, which was incompatible with const functions and introduced too much of the bloat in the generator.
eldar
parents:
294
diff
changeset
|
320 |
|
463563fc9e17
more of QList. const functions in C++ are now const in D too. Drop of the store result feature, which was incompatible with const functions and introduced too much of the bloat in the generator.
eldar
parents:
294
diff
changeset
|
321 struct QList(T, alias Default = Dummy) |
| 291 | 322 { |
|
295
463563fc9e17
more of QList. const functions in C++ are now const in D too. Drop of the store result feature, which was incompatible with const functions and introduced too much of the bloat in the generator.
eldar
parents:
294
diff
changeset
|
323 static if (is(Default == Dummy)) |
|
463563fc9e17
more of QList. const functions in C++ are now const in D too. Drop of the store result feature, which was incompatible with const functions and introduced too much of the bloat in the generator.
eldar
parents:
294
diff
changeset
|
324 alias QTypeInfo!T TI; |
|
463563fc9e17
more of QList. const functions in C++ are now const in D too. Drop of the store result feature, which was incompatible with const functions and introduced too much of the bloat in the generator.
eldar
parents:
294
diff
changeset
|
325 else |
|
463563fc9e17
more of QList. const functions in C++ are now const in D too. Drop of the store result feature, which was incompatible with const functions and introduced too much of the bloat in the generator.
eldar
parents:
294
diff
changeset
|
326 alias Default TI; |
|
463563fc9e17
more of QList. const functions in C++ are now const in D too. Drop of the store result feature, which was incompatible with const functions and introduced too much of the bloat in the generator.
eldar
parents:
294
diff
changeset
|
327 |
| 291 | 328 struct Node |
| 329 { | |
| 330 void *v; | |
| 292 | 331 |
| 296 | 332 static if (isQObjectType!T || isObjectType!T || isValueType!T || is(T == string)) // binded Qt types |
| 292 | 333 { |
| 334 T t() | |
| 335 { | |
| 296 | 336 static if(is(T == string)) |
| 337 { | |
| 338 void* ptr = cast(void*)(TI.isLarge || TI.isStatic ? v : &this); | |
| 339 return QString.toNativeString(ptr); | |
| 340 } | |
| 341 else static if (isValueType!T) | |
| 293 | 342 { |
| 343 void* ptr = cast(void*)(isLarge!T() || isStatic!T() ? v : &this); | |
| 344 return new T(ptr, QtdObjectFlags.nativeOwnership); | |
| 345 } | |
| 346 else | |
| 347 { | |
| 348 return T.__getObject( *cast(void**)(&this) ); | |
| 349 } | |
| 292 | 350 } |
| 351 } | |
| 293 | 352 else // native types |
| 292 | 353 { |
| 354 ref T t() | |
| 355 { | |
|
295
463563fc9e17
more of QList. const functions in C++ are now const in D too. Drop of the store result feature, which was incompatible with const functions and introduced too much of the bloat in the generator.
eldar
parents:
294
diff
changeset
|
356 static if(TI.isLarge || TI.isStatic) |
|
463563fc9e17
more of QList. const functions in C++ are now const in D too. Drop of the store result feature, which was incompatible with const functions and introduced too much of the bloat in the generator.
eldar
parents:
294
diff
changeset
|
357 return *cast(T*)(v); |
|
463563fc9e17
more of QList. const functions in C++ are now const in D too. Drop of the store result feature, which was incompatible with const functions and introduced too much of the bloat in the generator.
eldar
parents:
294
diff
changeset
|
358 else |
|
463563fc9e17
more of QList. const functions in C++ are now const in D too. Drop of the store result feature, which was incompatible with const functions and introduced too much of the bloat in the generator.
eldar
parents:
294
diff
changeset
|
359 return *cast(T*)(&this); |
| 292 | 360 } |
| 361 } | |
| 291 | 362 } |
| 363 | |
| 364 union { | |
| 365 QListData p; | |
| 366 QListData.Data* d; | |
| 367 } | |
| 368 | |
| 369 public: | |
| 370 void output() | |
| 371 { | |
| 372 writeln("QList atomic ", d.ref_.load()); | |
| 373 } | |
| 374 | |
| 375 static QList!T opCall() | |
| 376 { | |
| 377 QList!T res; | |
| 378 writeln("QList opCall"); | |
| 379 | |
| 380 res.d = &QListData.shared_null; | |
| 381 res.d.ref_.increment(); | |
| 382 | |
| 383 return res; | |
| 384 } | |
| 385 | |
| 386 this(this) | |
| 387 { | |
| 388 writeln("QList postblit"); | |
| 389 d.ref_.increment(); | |
| 390 if (!d.sharable) | |
| 391 detach_helper(); | |
| 392 } | |
| 393 | |
| 394 ~this() | |
| 395 { | |
| 396 writeln("QList ~this"); | |
| 397 if (d && !d.ref_.decrement()) | |
| 398 free(d); | |
| 399 } | |
| 400 | |
| 401 ref QList!T opAssign(const ref QList!T l) | |
| 402 { | |
| 403 writeln("QList opAssign"); | |
| 404 if (d != l.d) { | |
| 405 l.d.ref_.increment(); | |
| 406 if (!d.ref_.decrement()) | |
| 407 free(d); | |
| 408 d = cast(QListData.Data*)l.d; | |
| 409 if (!d.sharable) | |
| 410 detach_helper(); | |
| 411 } | |
| 412 return this; | |
| 413 } | |
| 414 | |
| 292 | 415 int length() const { return p.size(); } |
| 416 int size() const { return length; } | |
| 417 | |
| 291 | 418 void detach() { if (d.ref_.load() != 1) detach_helper(); } |
| 419 | |
| 420 private void detach_helper() | |
| 421 { | |
| 422 Node *n = cast(Node*)(p.begin()); | |
| 423 QListData.Data* x = p.detach2(); | |
| 424 node_copy(cast(Node*)(p.begin()), cast(Node*)(p.end()), n); | |
| 425 if (!x.ref_.decrement()) | |
| 426 free(x); | |
| 427 } | |
| 428 | |
| 293 | 429 |
| 291 | 430 void append(const T t) // fix to const ref for complex types TODO |
| 431 { | |
| 432 detach(); | |
| 293 | 433 static if (isQObjectType!T || isObjectType!T || isValueType!T) |
| 291 | 434 { |
| 435 node_construct(cast(Node*)(p.append()), t); | |
| 436 } | |
| 292 | 437 else |
| 291 | 438 { |
| 439 const T cpy = t; | |
| 440 node_construct(cast(Node*)(p.append()), cpy); | |
| 441 } | |
| 442 } | |
| 292 | 443 |
| 296 | 444 static if (isQObjectType!T || isObjectType!T || isValueType!T || is(T == string)) |
| 291 | 445 { |
| 292 | 446 T at(int i) const |
| 447 { | |
| 448 assert(i >= 0 && i < p.size(), "QList!T.at(): index out of range"); | |
| 449 return (cast(Node*)(p.at(i))).t(); | |
| 450 } | |
| 296 | 451 T opIndex(int i) |
| 452 { | |
| 453 assert(i >= 0 && i < p.size(), "QList!T.at(): index out of range"); | |
| 454 return (cast(Node*)(p.at(i))).t(); | |
| 455 } | |
| 291 | 456 } |
| 292 | 457 else |
| 291 | 458 { |
| 292 | 459 ref const (T) at(int i) const |
| 460 { | |
| 461 assert(i >= 0 && i < p.size(), "QList!T.at(): index out of range"); | |
| 462 return (cast(Node*)(p.at(i))).t(); | |
| 463 } | |
| 296 | 464 ref T opIndex(int i) |
| 465 { | |
| 466 assert(i >= 0 && i < p.size(), "QList!T.at(): index out of range"); | |
| 467 return (cast(Node*)(p.at(i))).t(); | |
| 468 } | |
| 292 | 469 } |
| 470 | |
| 293 | 471 static if (isQObjectType!T || isObjectType!T || isValueType!T) //binded types |
| 472 void node_construct(Node *n, const T t) | |
| 473 { | |
| 474 static if (isValueType!T) | |
| 475 { | |
| 476 if (isLarge!T() || isStatic!T()) // TODO should be static if | |
| 294 | 477 n.v = T.__constructNativeCopy(t.__nativeId); // n.v = new T(t); |
| 293 | 478 else if (isComplex!T()) |
| 294 | 479 T.__constructPlacedNativeCopy(t.__nativeId, n); // new (n) T(t); |
| 293 | 480 else |
| 294 | 481 T.__constructPlacedNativeCopy(t.__nativeId, n); // TODO should be *cast(T*)(n) = cast(T)(t); as it is a primitive type. fix when they are implemented with structs |
| 293 | 482 } |
| 483 else // in case of QObject or Object Qt types we place a pointer to a native object in the node | |
| 484 n = cast(Node*) t.__nativeId; | |
| 485 } | |
| 296 | 486 else static if (is(T == string)) |
| 487 { | |
| 488 void node_construct(Node *n, T t) | |
| 489 { | |
| 490 QString.__constructPlacedQString(n, t); | |
| 491 } | |
| 492 } | |
| 293 | 493 else // native types |
| 292 | 494 void node_construct(Node *n, const ref T t) |
| 495 { | |
| 296 | 496 static if (TI.isLarge || TI.isStatic) |
|
295
463563fc9e17
more of QList. const functions in C++ are now const in D too. Drop of the store result feature, which was incompatible with const functions and introduced too much of the bloat in the generator.
eldar
parents:
294
diff
changeset
|
497 n.v = q_new!T(t); // n.v = new T(t); |
| 296 | 498 else static if (TI.isComplex) |
|
295
463563fc9e17
more of QList. const functions in C++ are now const in D too. Drop of the store result feature, which was incompatible with const functions and introduced too much of the bloat in the generator.
eldar
parents:
294
diff
changeset
|
499 q_new_at(n, t); // new (n) T(t); |
| 296 | 500 else |
| 293 | 501 *cast(T*)(n) = cast(T)(t); |
| 292 | 502 } |
| 291 | 503 |
| 504 void node_copy(Node *from, Node *to, Node *src) | |
| 505 { | |
| 294 | 506 writeln("QList node_copy"); |
|
295
463563fc9e17
more of QList. const functions in C++ are now const in D too. Drop of the store result feature, which was incompatible with const functions and introduced too much of the bloat in the generator.
eldar
parents:
294
diff
changeset
|
507 static if (isQObjectType!T || isObjectType!T) |
|
463563fc9e17
more of QList. const functions in C++ are now const in D too. Drop of the store result feature, which was incompatible with const functions and introduced too much of the bloat in the generator.
eldar
parents:
294
diff
changeset
|
508 {} // ensure to do nothing. copying only a pointer |
| 296 | 509 else static if(is(T == string)) |
| 510 { | |
| 511 while(from != to) // TODO when porting to Qt 5 ensure that QTypeInfo<QString>.isLarge and .isStatic == false | |
| 512 QString.__constructPlacedNativeCopy(src++, from++); // new (from++) T(*reinterpret_cast<T*>(src++)); | |
| 513 } | |
|
295
463563fc9e17
more of QList. const functions in C++ are now const in D too. Drop of the store result feature, which was incompatible with const functions and introduced too much of the bloat in the generator.
eldar
parents:
294
diff
changeset
|
514 else static if (isValueType!T) |
|
463563fc9e17
more of QList. const functions in C++ are now const in D too. Drop of the store result feature, which was incompatible with const functions and introduced too much of the bloat in the generator.
eldar
parents:
294
diff
changeset
|
515 { |
|
463563fc9e17
more of QList. const functions in C++ are now const in D too. Drop of the store result feature, which was incompatible with const functions and introduced too much of the bloat in the generator.
eldar
parents:
294
diff
changeset
|
516 if (TI.isLarge || TI.isStatic) // TODO should be static if |
|
463563fc9e17
more of QList. const functions in C++ are now const in D too. Drop of the store result feature, which was incompatible with const functions and introduced too much of the bloat in the generator.
eldar
parents:
294
diff
changeset
|
517 while(from != to) |
|
463563fc9e17
more of QList. const functions in C++ are now const in D too. Drop of the store result feature, which was incompatible with const functions and introduced too much of the bloat in the generator.
eldar
parents:
294
diff
changeset
|
518 (from++).v = T.__constructNativeCopy((src++).v); // (from++)->v = new T(*reinterpret_cast<T*>((src++)->v)); |
|
463563fc9e17
more of QList. const functions in C++ are now const in D too. Drop of the store result feature, which was incompatible with const functions and introduced too much of the bloat in the generator.
eldar
parents:
294
diff
changeset
|
519 else if (TI.isComplex) |
|
463563fc9e17
more of QList. const functions in C++ are now const in D too. Drop of the store result feature, which was incompatible with const functions and introduced too much of the bloat in the generator.
eldar
parents:
294
diff
changeset
|
520 while(from != to) |
|
463563fc9e17
more of QList. const functions in C++ are now const in D too. Drop of the store result feature, which was incompatible with const functions and introduced too much of the bloat in the generator.
eldar
parents:
294
diff
changeset
|
521 T.__constructPlacedNativeCopy(src++, from++); // new (from++) T(*reinterpret_cast<T*>(src++)); |
|
463563fc9e17
more of QList. const functions in C++ are now const in D too. Drop of the store result feature, which was incompatible with const functions and introduced too much of the bloat in the generator.
eldar
parents:
294
diff
changeset
|
522 } |
|
463563fc9e17
more of QList. const functions in C++ are now const in D too. Drop of the store result feature, which was incompatible with const functions and introduced too much of the bloat in the generator.
eldar
parents:
294
diff
changeset
|
523 else static if (TI.isLarge || TI.isStatic) |
|
463563fc9e17
more of QList. const functions in C++ are now const in D too. Drop of the store result feature, which was incompatible with const functions and introduced too much of the bloat in the generator.
eldar
parents:
294
diff
changeset
|
524 while(from != to) |
|
463563fc9e17
more of QList. const functions in C++ are now const in D too. Drop of the store result feature, which was incompatible with const functions and introduced too much of the bloat in the generator.
eldar
parents:
294
diff
changeset
|
525 (from++).v = q_new!T(*cast(T*)((src++).v)); |
|
463563fc9e17
more of QList. const functions in C++ are now const in D too. Drop of the store result feature, which was incompatible with const functions and introduced too much of the bloat in the generator.
eldar
parents:
294
diff
changeset
|
526 else static if (TI.isComplex) |
| 291 | 527 while(from != to) |
|
295
463563fc9e17
more of QList. const functions in C++ are now const in D too. Drop of the store result feature, which was incompatible with const functions and introduced too much of the bloat in the generator.
eldar
parents:
294
diff
changeset
|
528 q_new_at(from++, *cast(T*)(src++)); |
| 291 | 529 } |
| 530 | |
| 531 void free(QListData.Data* data) | |
| 532 { | |
| 292 | 533 writeln("QList data destroyed"); |
| 291 | 534 node_destruct(cast(Node*)(data.array.ptr + data.begin), |
| 535 cast(Node*)(data.array.ptr + data.end)); | |
| 536 if (data.ref_.load() == 0) | |
| 293 | 537 qFree(data); |
| 291 | 538 } |
| 539 | |
| 540 void node_destruct(Node *from, Node *to) | |
| 293 | 541 { |
| 542 static if (isQObjectType!T || isObjectType!T) //binded types | |
| 543 {} // removing just pointers, do nothing | |
| 296 | 544 else static if (is(T == string)) |
| 545 { | |
| 546 while (from != to) | |
| 547 --to, QString.__callNativeDestructor(to); | |
| 548 } | |
| 549 else static if (isValueType!T) //binded value types | |
| 293 | 550 { |
| 551 if (isLarge!T() || isStatic!T()) // TODO should be static if | |
| 552 while (from != to) | |
| 294 | 553 --to, T.__deleteNativeObject(to.v); |
| 554 else if (isComplex!T()) | |
| 555 while (from != to) | |
| 556 --to, T.__callNativeDestructor(to); | |
| 293 | 557 } |
| 558 else | |
|
295
463563fc9e17
more of QList. const functions in C++ are now const in D too. Drop of the store result feature, which was incompatible with const functions and introduced too much of the bloat in the generator.
eldar
parents:
294
diff
changeset
|
559 { |
|
463563fc9e17
more of QList. const functions in C++ are now const in D too. Drop of the store result feature, which was incompatible with const functions and introduced too much of the bloat in the generator.
eldar
parents:
294
diff
changeset
|
560 static if (TI.isLarge || TI.isStatic) |
|
463563fc9e17
more of QList. const functions in C++ are now const in D too. Drop of the store result feature, which was incompatible with const functions and introduced too much of the bloat in the generator.
eldar
parents:
294
diff
changeset
|
561 while (from != to) --to, q_delete(cast(T*)(to.v)); |
|
463563fc9e17
more of QList. const functions in C++ are now const in D too. Drop of the store result feature, which was incompatible with const functions and introduced too much of the bloat in the generator.
eldar
parents:
294
diff
changeset
|
562 else static if (TI.isComplex) |
|
463563fc9e17
more of QList. const functions in C++ are now const in D too. Drop of the store result feature, which was incompatible with const functions and introduced too much of the bloat in the generator.
eldar
parents:
294
diff
changeset
|
563 while (from != to) --to, cast(T*)(to).__dtor(); |
| 293 | 564 } |
| 291 | 565 } |
| 296 | 566 |
| 567 //iteration support | |
| 568 int opApply(int delegate(ref T) dg) | |
| 569 { | |
| 570 int result = 0; | |
| 571 int sz = this.length; | |
| 572 for (int i = 0; i < sz; i++) | |
| 573 { | |
| 574 static if (isQtReference!T) | |
| 575 { | |
| 576 T t = this[i]; // hack to avoid "is not an lvalue" error, since dg accepts ref T | |
| 577 result = dg(t); | |
| 578 } | |
| 579 else | |
| 580 result = dg(this[i]); | |
| 581 | |
| 582 if (result) | |
| 583 break; | |
| 584 } | |
| 585 return result; | |
| 586 } | |
| 291 | 587 } |
| 588 | |
| 589 extern(C) void qtd_create_QList(void *nativeId); | |
|
295
463563fc9e17
more of QList. const functions in C++ are now const in D too. Drop of the store result feature, which was incompatible with const functions and introduced too much of the bloat in the generator.
eldar
parents:
294
diff
changeset
|
590 extern(C) void qtd_create_QList_double(void *nativeId); |
|
463563fc9e17
more of QList. const functions in C++ are now const in D too. Drop of the store result feature, which was incompatible with const functions and introduced too much of the bloat in the generator.
eldar
parents:
294
diff
changeset
|
591 |
| 292 | 592 extern(C) void qtd_create_QList_QObject(void *nativeId); |