Differential D15545 Diff 41757 tests/test_list_types_rust.cpp

Changeset View

Standalone View

View Options

tests/test_list_types_rust.cpp

Show First 20 Lines • Show All 165 Lines • ▼ Show 20 Line(s)
166} 166​}
167 167​
168bool List::setBoolean(int row, bool value) 168​bool List::setBoolean(int row, bool value)
169{ 169​{
170 bool set = false; 170​ bool set = false;
171 set = list_set_data_boolean(m_d, row, value); 171​ set = list_set_data_boolean(m_d, row, value);
172 if (set) { 172​ if (set) {
173 QModelIndex index = createIndex(row, 0, row); 173​ QModelIndex index = createIndex(row, 0, row);
174 emit dataChanged(index, index); 174​ Q_EMIT dataChanged(index, index);
175 } 175​ }
176 return set; 176​ return set;
177} 177​}
178 178​
179QByteArray List::bytearray(int row) const 179​QByteArray List::bytearray(int row) const
180{ 180​{
181 QByteArray b; 181​ QByteArray b;
182 list_data_bytearray(m_d, row, &b, set_qbytearray); 182​ list_data_bytearray(m_d, row, &b, set_qbytearray);
183 return b; 183​ return b;
184} 184​}
185 185​
186bool List::setBytearray(int row, const QByteArray& value) 186​bool List::setBytearray(int row, const QByteArray& value)
187{ 187​{
188 bool set = false; 188​ bool set = false;
189 set = list_set_data_bytearray(m_d, row, value.data(), value.length()); 189​ set = list_set_data_bytearray(m_d, row, value.data(), value.length());
190 if (set) { 190​ if (set) {
191 QModelIndex index = createIndex(row, 0, row); 191​ QModelIndex index = createIndex(row, 0, row);
192 emit dataChanged(index, index); 192​ Q_EMIT dataChanged(index, index);
193 } 193​ }
194 return set; 194​ return set;
195} 195​}
196 196​
197float List::f32(int row) const 197​float List::f32(int row) const
198{ 198​{
199 return list_data_f32(m_d, row); 199​ return list_data_f32(m_d, row);
200} 200​}
201 201​
202bool List::setF32(int row, float value) 202​bool List::setF32(int row, float value)
203{ 203​{
204 bool set = false; 204​ bool set = false;
205 set = list_set_data_f32(m_d, row, value); 205​ set = list_set_data_f32(m_d, row, value);
206 if (set) { 206​ if (set) {
207 QModelIndex index = createIndex(row, 0, row); 207​ QModelIndex index = createIndex(row, 0, row);
208 emit dataChanged(index, index); 208​ Q_EMIT dataChanged(index, index);
209 } 209​ }
210 return set; 210​ return set;
211} 211​}
212 212​
213double List::f64(int row) const 213​double List::f64(int row) const
214{ 214​{
215 return list_data_f64(m_d, row); 215​ return list_data_f64(m_d, row);
216} 216​}
217 217​
218bool List::setF64(int row, double value) 218​bool List::setF64(int row, double value)
219{ 219​{
220 bool set = false; 220​ bool set = false;
221 set = list_set_data_f64(m_d, row, value); 221​ set = list_set_data_f64(m_d, row, value);
222 if (set) { 222​ if (set) {
223 QModelIndex index = createIndex(row, 0, row); 223​ QModelIndex index = createIndex(row, 0, row);
224 emit dataChanged(index, index); 224​ Q_EMIT dataChanged(index, index);
225 } 225​ }
226 return set; 226​ return set;
227} 227​}
228 228​
229qint16 List::i16(int row) const 229​qint16 List::i16(int row) const
230{ 230​{
231 return list_data_i16(m_d, row); 231​ return list_data_i16(m_d, row);
232} 232​}
233 233​
234bool List::setI16(int row, qint16 value) 234​bool List::setI16(int row, qint16 value)
235{ 235​{
236 bool set = false; 236​ bool set = false;
237 set = list_set_data_i16(m_d, row, value); 237​ set = list_set_data_i16(m_d, row, value);
238 if (set) { 238​ if (set) {
239 QModelIndex index = createIndex(row, 0, row); 239​ QModelIndex index = createIndex(row, 0, row);
240 emit dataChanged(index, index); 240​ Q_EMIT dataChanged(index, index);
241 } 241​ }
242 return set; 242​ return set;
243} 243​}
244 244​
245qint32 List::i32(int row) const 245​qint32 List::i32(int row) const
246{ 246​{
247 return list_data_i32(m_d, row); 247​ return list_data_i32(m_d, row);
248} 248​}
249 249​
250bool List::setI32(int row, qint32 value) 250​bool List::setI32(int row, qint32 value)
251{ 251​{
252 bool set = false; 252​ bool set = false;
253 set = list_set_data_i32(m_d, row, value); 253​ set = list_set_data_i32(m_d, row, value);
254 if (set) { 254​ if (set) {
255 QModelIndex index = createIndex(row, 0, row); 255​ QModelIndex index = createIndex(row, 0, row);
256 emit dataChanged(index, index); 256​ Q_EMIT dataChanged(index, index);
257 } 257​ }
258 return set; 258​ return set;
259} 259​}
260 260​
261qint64 List::i64(int row) const 261​qint64 List::i64(int row) const
262{ 262​{
263 return list_data_i64(m_d, row); 263​ return list_data_i64(m_d, row);
264} 264​}
265 265​
266bool List::setI64(int row, qint64 value) 266​bool List::setI64(int row, qint64 value)
267{ 267​{
268 bool set = false; 268​ bool set = false;
269 set = list_set_data_i64(m_d, row, value); 269​ set = list_set_data_i64(m_d, row, value);
270 if (set) { 270​ if (set) {
271 QModelIndex index = createIndex(row, 0, row); 271​ QModelIndex index = createIndex(row, 0, row);
272 emit dataChanged(index, index); 272​ Q_EMIT dataChanged(index, index);
273 } 273​ }
274 return set; 274​ return set;
275} 275​}
276 276​
277qint8 List::i8(int row) const 277​qint8 List::i8(int row) const
278{ 278​{
279 return list_data_i8(m_d, row); 279​ return list_data_i8(m_d, row);
280} 280​}
281 281​
282bool List::setI8(int row, qint8 value) 282​bool List::setI8(int row, qint8 value)
283{ 283​{
284 bool set = false; 284​ bool set = false;
285 set = list_set_data_i8(m_d, row, value); 285​ set = list_set_data_i8(m_d, row, value);
286 if (set) { 286​ if (set) {
287 QModelIndex index = createIndex(row, 0, row); 287​ QModelIndex index = createIndex(row, 0, row);
288 emit dataChanged(index, index); 288​ Q_EMIT dataChanged(index, index);
289 } 289​ }
290 return set; 290​ return set;
291} 291​}
292 292​
293QVariant List::optionalBoolean(int row) const 293​QVariant List::optionalBoolean(int row) const
294{ 294​{
295 QVariant v; 295​ QVariant v;
296 v = list_data_optional_boolean(m_d, row); 296​ v = list_data_optional_boolean(m_d, row);
297 return v; 297​ return v;
298} 298​}
299 299​
300bool List::setOptionalBoolean(int row, const QVariant& value) 300​bool List::setOptionalBoolean(int row, const QVariant& value)
301{ 301​{
302 bool set = false; 302​ bool set = false;
303 if (value.isNull() || !value.isValid()) { 303​ if (value.isNull() || !value.isValid()) {
304 set = list_set_data_optional_boolean_none(m_d, row); 304​ set = list_set_data_optional_boolean_none(m_d, row);
305 } else { 305​ } else {
306 if (!value.canConvert(qMetaTypeId<bool>())) { 306​ if (!value.canConvert(qMetaTypeId<bool>())) {
307 return false; 307​ return false;
308 } 308​ }
309 set = list_set_data_optional_boolean(m_d, row, value.value<bool>()); 309​ set = list_set_data_optional_boolean(m_d, row, value.value<bool>());
310 } 310​ }
311 if (set) { 311​ if (set) {
312 QModelIndex index = createIndex(row, 0, row); 312​ QModelIndex index = createIndex(row, 0, row);
313 emit dataChanged(index, index); 313​ Q_EMIT dataChanged(index, index);
314 } 314​ }
315 return set; 315​ return set;
316} 316​}
317 317​
318QByteArray List::optionalBytearray(int row) const 318​QByteArray List::optionalBytearray(int row) const
319{ 319​{
320 QByteArray b; 320​ QByteArray b;
321 list_data_optional_bytearray(m_d, row, &b, set_qbytearray); 321​ list_data_optional_bytearray(m_d, row, &b, set_qbytearray);
322 return b; 322​ return b;
323} 323​}
324 324​
325bool List::setOptionalBytearray(int row, const QByteArray& value) 325​bool List::setOptionalBytearray(int row, const QByteArray& value)
326{ 326​{
327 bool set = false; 327​ bool set = false;
328 if (value.isNull()) { 328​ if (value.isNull()) {
329 set = list_set_data_optional_bytearray_none(m_d, row); 329​ set = list_set_data_optional_bytearray_none(m_d, row);
330 } else { 330​ } else {
331 set = list_set_data_optional_bytearray(m_d, row, value.data(), value.length()); 331​ set = list_set_data_optional_bytearray(m_d, row, value.data(), value.length());
332 } 332​ }
333 if (set) { 333​ if (set) {
334 QModelIndex index = createIndex(row, 0, row); 334​ QModelIndex index = createIndex(row, 0, row);
335 emit dataChanged(index, index); 335​ Q_EMIT dataChanged(index, index);
336 } 336​ }
337 return set; 337​ return set;
338} 338​}
339 339​
340QString List::optionalString(int row) const 340​QString List::optionalString(int row) const
341{ 341​{
342 QString s; 342​ QString s;
343 list_data_optional_string(m_d, row, &s, set_qstring); 343​ list_data_optional_string(m_d, row, &s, set_qstring);
344 return s; 344​ return s;
345} 345​}
346 346​
347bool List::setOptionalString(int row, const QString& value) 347​bool List::setOptionalString(int row, const QString& value)
348{ 348​{
349 bool set = false; 349​ bool set = false;
350 if (value.isNull()) { 350​ if (value.isNull()) {
351 set = list_set_data_optional_string_none(m_d, row); 351​ set = list_set_data_optional_string_none(m_d, row);
352 } else { 352​ } else {
353 set = list_set_data_optional_string(m_d, row, value.utf16(), value.length()); 353​ set = list_set_data_optional_string(m_d, row, value.utf16(), value.length());
354 } 354​ }
355 if (set) { 355​ if (set) {
356 QModelIndex index = createIndex(row, 0, row); 356​ QModelIndex index = createIndex(row, 0, row);
357 emit dataChanged(index, index); 357​ Q_EMIT dataChanged(index, index);
358 } 358​ }
359 return set; 359​ return set;
360} 360​}
361 361​
362QString List::string(int row) const 362​QString List::string(int row) const
363{ 363​{
364 QString s; 364​ QString s;
365 list_data_string(m_d, row, &s, set_qstring); 365​ list_data_string(m_d, row, &s, set_qstring);
366 return s; 366​ return s;
367} 367​}
368 368​
369bool List::setString(int row, const QString& value) 369​bool List::setString(int row, const QString& value)
370{ 370​{
371 bool set = false; 371​ bool set = false;
372 set = list_set_data_string(m_d, row, value.utf16(), value.length()); 372​ set = list_set_data_string(m_d, row, value.utf16(), value.length());
373 if (set) { 373​ if (set) {
374 QModelIndex index = createIndex(row, 0, row); 374​ QModelIndex index = createIndex(row, 0, row);
375 emit dataChanged(index, index); 375​ Q_EMIT dataChanged(index, index);
376 } 376​ }
377 return set; 377​ return set;
378} 378​}
379 379​
380quint16 List::u16(int row) const 380​quint16 List::u16(int row) const
381{ 381​{
382 return list_data_u16(m_d, row); 382​ return list_data_u16(m_d, row);
383} 383​}
384 384​
385bool List::setU16(int row, quint16 value) 385​bool List::setU16(int row, quint16 value)
386{ 386​{
387 bool set = false; 387​ bool set = false;
388 set = list_set_data_u16(m_d, row, value); 388​ set = list_set_data_u16(m_d, row, value);
389 if (set) { 389​ if (set) {
390 QModelIndex index = createIndex(row, 0, row); 390​ QModelIndex index = createIndex(row, 0, row);
391 emit dataChanged(index, index); 391​ Q_EMIT dataChanged(index, index);
392 } 392​ }
393 return set; 393​ return set;
394} 394​}
395 395​
396quint32 List::u32(int row) const 396​quint32 List::u32(int row) const
397{ 397​{
398 return list_data_u32(m_d, row); 398​ return list_data_u32(m_d, row);
399} 399​}
400 400​
401bool List::setU32(int row, quint32 value) 401​bool List::setU32(int row, quint32 value)
402{ 402​{
403 bool set = false; 403​ bool set = false;
404 set = list_set_data_u32(m_d, row, value); 404​ set = list_set_data_u32(m_d, row, value);
405 if (set) { 405​ if (set) {
406 QModelIndex index = createIndex(row, 0, row); 406​ QModelIndex index = createIndex(row, 0, row);
407 emit dataChanged(index, index); 407​ Q_EMIT dataChanged(index, index);
408 } 408​ }
409 return set; 409​ return set;
410} 410​}
411 411​
412quint64 List::u64(int row) const 412​quint64 List::u64(int row) const
413{ 413​{
414 return list_data_u64(m_d, row); 414​ return list_data_u64(m_d, row);
415} 415​}
416 416​
417bool List::setU64(int row, quint64 value) 417​bool List::setU64(int row, quint64 value)
418{ 418​{
419 bool set = false; 419​ bool set = false;
420 set = list_set_data_u64(m_d, row, value); 420​ set = list_set_data_u64(m_d, row, value);
421 if (set) { 421​ if (set) {
422 QModelIndex index = createIndex(row, 0, row); 422​ QModelIndex index = createIndex(row, 0, row);
423 emit dataChanged(index, index); 423​ Q_EMIT dataChanged(index, index);
424 } 424​ }
425 return set; 425​ return set;
426} 426​}
427 427​
428quint8 List::u8(int row) const 428​quint8 List::u8(int row) const
429{ 429​{
430 return list_data_u8(m_d, row); 430​ return list_data_u8(m_d, row);
431} 431​}
432 432​
433bool List::setU8(int row, quint8 value) 433​bool List::setU8(int row, quint8 value)
434{ 434​{
435 bool set = false; 435​ bool set = false;
436 set = list_set_data_u8(m_d, row, value); 436​ set = list_set_data_u8(m_d, row, value);
437 if (set) { 437​ if (set) {
438 QModelIndex index = createIndex(row, 0, row); 438​ QModelIndex index = createIndex(row, 0, row);
439 emit dataChanged(index, index); 439​ Q_EMIT dataChanged(index, index);
440 } 440​ }
441 return set; 441​ return set;
442} 442​}
443 443​
444QVariant List::data(const QModelIndex &index, int role) const 444​QVariant List::data(const QModelIndex &index, int role) const
445{ 445​{
446 Q_ASSERT(rowCount(index.parent()) > index.row()); 446​ Q_ASSERT(rowCount(index.parent()) > index.row());
447 switch (index.column()) { 447​ switch (index.column()) {
▲ Show 20 Lines • Show All 196 Lines • ▼ Show 20 Line(s)
644{ 644​{
645 initHeaderData(); 645​ initHeaderData();
646} 646​}
647 647​
648List::List(QObject *parent): 648​List::List(QObject *parent):
649 QAbstractItemModel(parent), 649​ QAbstractItemModel(parent),
650 m_d(list_new(this, 650​ m_d(list_new(this,
651 [](const List* o) { 651​ [](const List* o) {
652 emit o->newDataReady(QModelIndex()); 652​ Q_EMIT o->newDataReady(QModelIndex());
653 }, 653​ },
654 [](List* o) { 654​ [](List* o) {
655 emit o->layoutAboutToBeChanged(); 655​ Q_EMIT o->layoutAboutToBeChanged();
656 }, 656​ },
657 [](List* o) { 657​ [](List* o) {
658 o->updatePersistentIndexes(); 658​ o->updatePersistentIndexes();
659 emit o->layoutChanged(); 659​ Q_EMIT o->layoutChanged();
660 }, 660​ },
661 [](List* o, quintptr first, quintptr last) { 661​ [](List* o, quintptr first, quintptr last) {
662 o->dataChanged(o->createIndex(first, 0, first), 662​ o->dataChanged(o->createIndex(first, 0, first),
663 o->createIndex(last, 0, last)); 663​ o->createIndex(last, 0, last));
664 }, 664​ },
665 [](List* o) { 665​ [](List* o) {
666 o->beginResetModel(); 666​ o->beginResetModel();
667 }, 667​ },
Show All 38 Lines