io/qdatastream.cpp

noswap = QSysInfo::ByteOrder == QSysInfo::BigEndian;

executed (the execution status of this line is deduced): ver = DefaultStreamVersion;

269

executed (the execution status of this line is deduced): noswap = QSysInfo::ByteOrder == QSysInfo::BigEndian;

270

executed (the execution status of this line is deduced): q_status = Ok;

271

byteorder = BigEndian; // default byte order

executed: }

Execution Count:275

275

272 -

273 /*! -

274 Constructs a data stream that uses the I/O device \a d. -

275 -

276 \warning If you use QSocket or QSocketDevice as the I/O device \a d -

277 for reading data, you must make sure that enough data is available -

278 on the socket for the operation to successfully proceed; -

279 QDataStream does not have any means to handle or recover from -

280 short-reads. -

281 -

282 \sa setDevice(), device() -

283 */ -

284 -

285 QDataStream::QDataStream(QIODevice *d) -

286 { -

287

dev = d; // set device

executed (the execution status of this line is deduced): dev = d;

288

owndev = false;

executed (the execution status of this line is deduced): owndev = false;

289

executed (the execution status of this line is deduced): byteorder = BigEndian;

290

noswap = QSysInfo::ByteOrder == QSysInfo::BigEndian;

executed (the execution status of this line is deduced): ver = DefaultStreamVersion;

291

executed (the execution status of this line is deduced): noswap = QSysInfo::ByteOrder == QSysInfo::BigEndian;

292

executed (the execution status of this line is deduced): q_status = Ok;

293

QBuffer *buf = new QBuffer(a);

executed: }

Execution Count:3342

3342

294 -

295 /*! -

296 \fn QDataStream::QDataStream(QByteArray *a, QIODevice::OpenMode mode) -

297 -

298 Constructs a data stream that operates on a byte array, \a a. The -

299 \a mode describes how the device is to be used. -

300 -

301 Alternatively, you can use QDataStream(const QByteArray &) if you -

302 just want to read from a byte array. -

303 -

304 Since QByteArray is not a QIODevice subclass, internally a QBuffer -

305 is created to wrap the byte array. -

306 */ -

307 -

308 QDataStream::QDataStream(QByteArray *a, QIODevice::OpenMode flags) -

309 { -

310

executed (the execution status of this line is deduced): QBuffer *buf = new QBuffer(a);

311 #ifndef QT_NO_QOBJECT -

312

buf->blockSignals(true);

executed (the execution status of this line is deduced): buf->blockSignals(true);

313 #endif -

314

buf->open(flags);

executed (the execution status of this line is deduced): buf->open(flags);

315

dev = buf;

executed (the execution status of this line is deduced): dev = buf;

316

owndev = true;

executed (the execution status of this line is deduced): owndev = true;

317

byteorder = BigEndian;

executed (the execution status of this line is deduced): byteorder = BigEndian;

318

noswap = QSysInfo::ByteOrder == QSysInfo::BigEndian;

executed (the execution status of this line is deduced): ver = DefaultStreamVersion;

319

executed (the execution status of this line is deduced): noswap = QSysInfo::ByteOrder == QSysInfo::BigEndian;

320

executed (the execution status of this line is deduced): q_status = Ok;

321

QBuffer *buf = new QBuffer;

executed: }

Execution Count:3168

3168

322 -

323 /*! -

324 Constructs a read-only data stream that operates on byte array \a a. -

325 Use QDataStream(QByteArray*, int) if you want to write to a byte -

326 array. -

327 -

328 Since QByteArray is not a QIODevice subclass, internally a QBuffer -

329 is created to wrap the byte array. -

330 */ -

331 QDataStream::QDataStream(const QByteArray &a) -

332 { -

333

executed (the execution status of this line is deduced): QBuffer *buf = new QBuffer;

334 #ifndef QT_NO_QOBJECT -

335

buf->blockSignals(true);

executed (the execution status of this line is deduced): buf->blockSignals(true);

336 #endif -

337

buf->setData(a);

executed (the execution status of this line is deduced): buf->setData(a);

338

buf->open(QIODevice::ReadOnly);

executed (the execution status of this line is deduced): buf->open(QIODevice::ReadOnly);

339

dev = buf;

executed (the execution status of this line is deduced): dev = buf;

340

owndev = true;

executed (the execution status of this line is deduced): owndev = true;

341

byteorder = BigEndian;

executed (the execution status of this line is deduced): byteorder = BigEndian;

342

noswap = QSysInfo::ByteOrder == QSysInfo::BigEndian;

executed (the execution status of this line is deduced): ver = DefaultStreamVersion;

343

executed (the execution status of this line is deduced): noswap = QSysInfo::ByteOrder == QSysInfo::BigEndian;

344

executed (the execution status of this line is deduced): q_status = Ok;

345

executed: }

Execution Count:33

346 -

347 /*! -

348 Destroys the data stream. -

349 -

350 The destructor will not affect the current I/O device, unless it is -

351 an internal I/O device (e.g. a QBuffer) processing a QByteArray -

352 passed in the \e constructor, in which case the internal I/O device -

353 is destroyed. -

354 */ -

355 -

356 QDataStream::~QDataStream() -

357 { -

358

if (owndev)

evaluated: owndev

TRUE	FALSE
yes Evaluation Count:3201	yes Evaluation Count:3617

3201-3617

359

delete dev;

executed: delete dev;

Execution Count:3201

3201

360

executed: }

Execution Count:6818

6818

361 -

362 -

363 /*! -

364 \fn QIODevice *QDataStream::device() const -

365 -

366 Returns the I/O device currently set, or 0 if no -

367 device is currently set. -

368 -

369 \sa setDevice() -

370 */ -

371 -

372 /*! -

373 void QDataStream::setDevice(QIODevice *d) -

374 -

375 Sets the I/O device to \a d, which can be 0 -

376 to unset to current I/O device. -

377 -

378 \sa device() -

379 */ -

380 -

381 void QDataStream::setDevice(QIODevice *d) -

382 { -

383

if (owndev) {

partially evaluated: owndev

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:67

0-67

384

delete dev;

never executed (the execution status of this line is deduced): delete dev;

385

owndev = false;

never executed (the execution status of this line is deduced): owndev = false;

never executed: }

executed (the execution status of this line is deduced): dev = d;

388

executed: }

Execution Count:67

389 -

390 /*! -

391 \obsolete -

392 Unsets the I/O device. -

393 Use setDevice(0) instead. -

394 */ -

395 -

396 void QDataStream::unsetDevice() -

397 { -

398

setDevice(0);

executed (the execution status of this line is deduced): setDevice(0);

399

return dev ? dev->atEnd() : true;

executed: }

Execution Count:20

400 -

401 -

402 /*! -

403 \fn bool QDataStream::atEnd() const -

404 -

405 Returns true if the I/O device has reached the end position (end of -

406 the stream or file) or if there is no I/O device set; otherwise -

407 returns false. -

408 -

409 \sa QIODevice::atEnd() -

410 */ -

411 -

412 bool QDataStream::atEnd() const -

413 { -

414

executed: return dev ? dev->atEnd() : true;

Execution Count:1406

1406

415 } -

416 -

417 /*! -

418 Returns the floating point precision of the data stream. -

419 -

420 \since 4.6 -

421 -

422 \sa FloatingPointPrecision, setFloatingPointPrecision() -

423 */ -

424 QDataStream::FloatingPointPrecision QDataStream::floatingPointPrecision() const -

425 { -

426

return d == 0 ? QDataStream::DoublePrecision : d->floatingPointPrecision;

executed: return d == 0 ? QDataStream::DoublePrecision : d->floatingPointPrecision;

Execution Count:9593

9593

427 } -

428 -

429 /*! -

430 Sets the floating point precision of the data stream to \a precision. If the floating point precision is -

431 DoublePrecision and the version of the data stream is Qt_4_6 or higher, all floating point -

432 numbers will be written and read with 64-bit precision. If the floating point precision is -

433 SinglePrecision and the version is Qt_4_6 or higher, all floating point numbers will be written -

434 and read with 32-bit precision. -

435 -

436 For versions prior to Qt_4_6, the precision of floating point numbers in the data stream depends -

437 on the stream operator called. -

438 -

439 The default is DoublePrecision. -

440 -

441 \warning This property must be set to the same value on the object that writes and the object -

442 that reads the data stream. -

443 -

444 \since 4.6 -

445 */ -

446 void QDataStream::setFloatingPointPrecision(QDataStream::FloatingPointPrecision precision) -

447 { -

448

if (d == 0)

partially evaluated: d == 0

TRUE	FALSE
yes Evaluation Count:58	no Evaluation Count:0

0-58

449

d.reset(new QDataStreamPrivate());

executed: d.reset(new QDataStreamPrivate());

Execution Count:58

450

d->floatingPointPrecision = precision;

executed (the execution status of this line is deduced): d->floatingPointPrecision = precision;

451

executed: }

Execution Count:58

452 -

453 /*! -

454 Returns the status of the data stream. -

455 -

456 \sa Status, setStatus(), resetStatus() -

457 */ -

458 -

459 QDataStream::Status QDataStream::status() const -

460 { -

461

return q_status;

executed: return q_status;

Execution Count:14753

14753

462 } -

463 -

464 /*! -

465 Resets the status of the data stream. -

466 -

467 \sa Status, status(), setStatus() -

468 */ -

469 void QDataStream::resetStatus() -

470 { -

471

executed (the execution status of this line is deduced): q_status = Ok;

472

executed: }

Execution Count:465

465

473 -

474 /*! -

475 Sets the status of the data stream to the \a status given. -

476 -

477 Subsequent calls to setStatus() are ignored until resetStatus() -

478 is called. -

479 -

480 \sa Status, status(), resetStatus() -

481 */ -

482 void QDataStream::setStatus(Status status) -

483 { -

484

if (q_status == Ok)

evaluated: q_status == Ok

TRUE	FALSE
yes Evaluation Count:336	yes Evaluation Count:125

125-336

485

q_status = status;

executed: q_status = status;

Execution Count:336

336

486

if (QSysInfo::ByteOrder == QSysInfo::BigEndian)

executed: }

Execution Count:461

461

487 -

488 /*! -

489 \fn int QDataStream::byteOrder() const -

490 -

491 Returns the current byte order setting -- either BigEndian or -

492 LittleEndian. -

493 -

494 \sa setByteOrder() -

495 */ -

496 -

497 /*! -

498 Sets the serialization byte order to \a bo. -

499 -

500 The \a bo parameter can be QDataStream::BigEndian or -

501 QDataStream::LittleEndian. -

502 -

503 The default setting is big endian. We recommend leaving this -

504 setting unless you have special requirements. -

505 -

506 \sa byteOrder() -

507 */ -

508 -

509 void QDataStream::setByteOrder(ByteOrder bo) -

510 { -

511

byteorder = bo;

executed (the execution status of this line is deduced): byteorder = bo;

512

partially evaluated: QSysInfo::ByteOrder == QSysInfo::BigEndian

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:875

0-875

513

noswap = (byteorder == BigEndian);

never executed: noswap = (byteorder == BigEndian);

514 else -

515

noswap = (byteorder == LittleEndian);

executed: noswap = (byteorder == LittleEndian);

Execution Count:875

875

516 } -

517 -

518 -

519 /*! -

520 \enum QDataStream::Version -

521 -

522 This enum provides symbolic synonyms for the data serialization -

523 format version numbers. -

524 -

525 \value Qt_1_0 Version 1 (Qt 1.x) -

526 \value Qt_2_0 Version 2 (Qt 2.0) -

527 \value Qt_2_1 Version 3 (Qt 2.1, 2.2, 2.3) -

528 \value Qt_3_0 Version 4 (Qt 3.0) -

529 \value Qt_3_1 Version 5 (Qt 3.1, 3.2) -

530 \value Qt_3_3 Version 6 (Qt 3.3) -

531 \value Qt_4_0 Version 7 (Qt 4.0, Qt 4.1) -

532 \value Qt_4_1 Version 7 (Qt 4.0, Qt 4.1) -

533 \value Qt_4_2 Version 8 (Qt 4.2) -

534 \value Qt_4_3 Version 9 (Qt 4.3) -

535 \value Qt_4_4 Version 10 (Qt 4.4) -

536 \value Qt_4_5 Version 11 (Qt 4.5) -

537 \value Qt_4_6 Version 12 (Qt 4.6, Qt 4.7, Qt 4.8) -

538 \value Qt_4_7 Same as Qt_4_6. -

539 \value Qt_4_8 Same as Qt_4_6. -

540 \value Qt_4_9 Same as Qt_4_6. -

541 \value Qt_5_0 Version 13 (Qt 5.0) -

542 -

543 \sa setVersion(), version() -

544 */ -

545 -

546 /*! -

547 \fn int QDataStream::version() const -

548 -

549 Returns the version number of the data serialization format. -

550 -

551 \sa setVersion(), Version -

552 */ -

553 -

554 /*! -

555 \fn void QDataStream::setVersion(int v) -

556 -

557 Sets the version number of the data serialization format to \a v. -

558 -

559 You don't \e have to set a version if you are using the current -

560 version of Qt, but for your own custom binary formats we -

561 recommend that you do; see \l{Versioning} in the Detailed -

562 Description. -

563 -

564 To accommodate new functionality, the datastream serialization -

565 format of some Qt classes has changed in some versions of Qt. If -

566 you want to read data that was created by an earlier version of -

567 Qt, or write data that can be read by a program that was compiled -

568 with an earlier version of Qt, use this function to modify the -

569 serialization format used by QDataStream. -

570 -

571 \table -

572 \header \li Qt Version \li QDataStream Version -

573 \row \li Qt 4.6 \li 12 -

574 \row \li Qt 4.5 \li 11 -

575 \row \li Qt 4.4 \li 10 -

576 \row \li Qt 4.3 \li 9 -

577 \row \li Qt 4.2 \li 8 -

578 \row \li Qt 4.0, 4.1 \li 7 -

579 \row \li Qt 3.3 \li 6 -

580 \row \li Qt 3.1, 3.2 \li 5 -

581 \row \li Qt 3.0 \li 4 -

582 \row \li Qt 2.1, 2.2, 2.3 \li 3 -

583 \row \li Qt 2.0 \li 2 -

584 \row \li Qt 1.x \li 1 -

585 \endtable -

586 -

587 The \l Version enum provides symbolic constants for the different -

588 versions of Qt. For example: -

589 -

590 \snippet code/src_corelib_io_qdatastream.cpp 5 -

591 -

592 \sa version(), Version -

593 */ -

594 -

595 /***************************************************************************** -

596 QDataStream read functions -

597 *****************************************************************************/ -

598 -

599 /*! -

600 \fn QDataStream &QDataStream::operator>>(quint8 &i) -

601 \overload -

602 -

603 Reads an unsigned byte from the stream into \a i, and returns a -

604 reference to the stream. -

605 */ -

606 -

607 /*! -

608 Reads a signed byte from the stream into \a i, and returns a -

609 reference to the stream. -

610 */ -

611 -

612 QDataStream &QDataStream::operator>>(qint8 &i) -

613 { -

614

executed (the execution status of this line is deduced): i = 0;

615

never executed: return *this;

partially evaluated: !dev

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:17825

0-17825

616

char c;

executed (the execution status of this line is deduced): char c;

617

if (!dev->getChar(&c))

evaluated: !dev->getChar(&c)

TRUE	FALSE
yes Evaluation Count:28	yes Evaluation Count:17797

28-17797

618

executed: setStatus(ReadPastEnd);

Execution Count:28

619 else -

620

i = qint8(c);

executed: i = qint8(c);

Execution Count:17797

17797

621

executed: return *this;

Execution Count:17825

17825

622 } -

623 -

624 -

625 /*! -

626 \fn QDataStream &QDataStream::operator>>(quint16 &i) -

627 \overload -

628 -

629 Reads an unsigned 16-bit integer from the stream into \a i, and -

630 returns a reference to the stream. -

631 */ -

632 -

633 /*! -

634 \overload -

635 -

636 Reads a signed 16-bit integer from the stream into \a i, and -

637 returns a reference to the stream. -

638 */ -

639 -

640 QDataStream &QDataStream::operator>>(qint16 &i) -

641 { -

642

executed (the execution status of this line is deduced): i = 0;

643

if (dev->read((char *)&i, 2) != 2) {

never executed: return *this;

partially evaluated: !dev

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:6818

0-6818

644

evaluated: dev->read((char *)&i, 2) != 2

TRUE	FALSE
yes Evaluation Count:58	yes Evaluation Count:6760

58-6760

645

executed (the execution status of this line is deduced): i = 0;

646

executed (the execution status of this line is deduced): setStatus(ReadPastEnd);

647

executed: }

Execution Count:58

648

evaluated: !noswap

TRUE	FALSE
yes Evaluation Count:5464	yes Evaluation Count:1296

1296-5464

649

executed (the execution status of this line is deduced): i = qbswap(i);

650

executed: }

Execution Count:5464

5464

651

executed: }

Execution Count:6760

6760

652

executed: return *this;

Execution Count:6818

6818

653 } -

654 -

655 -

656 /*! -

657 \fn QDataStream &QDataStream::operator>>(quint32 &i) -

658 \overload -

659 -

660 Reads an unsigned 32-bit integer from the stream into \a i, and -

661 returns a reference to the stream. -

662 */ -

663 -

664 /*! -

665 \overload -

666 -

667 Reads a signed 32-bit integer from the stream into \a i, and -

668 returns a reference to the stream. -

669 */ -

670 -

671 QDataStream &QDataStream::operator>>(qint32 &i) -

672 { -

673

executed (the execution status of this line is deduced): i = 0;

674

if (dev->read((char *)&i, 4) != 4) {

never executed: return *this;

partially evaluated: !dev

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:52588

0-52588

675

evaluated: dev->read((char *)&i, 4) != 4

TRUE	FALSE
yes Evaluation Count:185	yes Evaluation Count:52403

185-52403

676

executed (the execution status of this line is deduced): i = 0;

677

executed (the execution status of this line is deduced): setStatus(ReadPastEnd);

678

executed: }

Execution Count:185

185

679

evaluated: !noswap

TRUE	FALSE
yes Evaluation Count:48860	yes Evaluation Count:3543

3543-48860

680

executed (the execution status of this line is deduced): i = qbswap(i);

681

executed: }

Execution Count:48860

48860

682

executed: }

Execution Count:52403

52403

683

executed: return *this;

Execution Count:52588

52588

684 } -

685 -

686 /*! -

687 \fn QDataStream &QDataStream::operator>>(quint64 &i) -

688 \overload -

689 -

690 Reads an unsigned 64-bit integer from the stream, into \a i, and -

691 returns a reference to the stream. -

692 */ -

693 -

694 /*! -

695 \overload -

696 -

697 Reads a signed 64-bit integer from the stream into \a i, and -

698 returns a reference to the stream. -

699 */ -

700 -

701 QDataStream &QDataStream::operator>>(qint64 &i) -

702 { -

703

i = qint64(0);

executed (the execution status of this line is deduced): i = qint64(0);

704

i = ((quint64)i1 << 32) + i2;

never executed: return *this;

partially evaluated: !dev

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:600

0-600

705

if (version() < 6) {

partially evaluated: version() < 6

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:600

0-600

706

quint32 i1, i2;

never executed (the execution status of this line is deduced): quint32 i1, i2;

707

*this >> i2 >> i1;

never executed (the execution status of this line is deduced): *this >> i2 >> i1;

708

never executed (the execution status of this line is deduced): i = ((quint64)i1 << 32) + i2;

709

if (dev->read((char *)&i, 8) != 8) {

never executed: }

710

evaluated: dev->read((char *)&i, 8) != 8

TRUE	FALSE
yes Evaluation Count:50	yes Evaluation Count:550

50-550

711

i = qint64(0);

executed (the execution status of this line is deduced): i = qint64(0);

712

executed (the execution status of this line is deduced): setStatus(ReadPastEnd);

713

executed: }

Execution Count:50

714

evaluated: !noswap

TRUE	FALSE
yes Evaluation Count:538	yes Evaluation Count:12

12-538

715

executed (the execution status of this line is deduced): i = qbswap(i);

716

executed: }

Execution Count:538

538

717

executed: }

Execution Count:550

550

718 } -

719

executed: return *this;

Execution Count:600

600

720 } -

721 -

722 /*! -

723 Reads a boolean value from the stream into \a i. Returns a -

724 reference to the stream. -

725 */ -

726 QDataStream &QDataStream::operator>>(bool &i) -

727 { -

728

qint8 v;

executed (the execution status of this line is deduced): qint8 v;

729

*this >> v;

executed (the execution status of this line is deduced): *this >> v;

730

i = !!v;

executed (the execution status of this line is deduced): i = !!v;

731

executed: return *this;

Execution Count:1260

1260

732 } -

733 -

734 /*! -

735 \overload -

736 -

737 Reads a floating point number from the stream into \a f, -

738 using the standard IEEE 754 format. Returns a reference to the -

739 stream. -

740 -

741 \sa setFloatingPointPrecision() -

742 */ -

743 -

744 QDataStream &QDataStream::operator>>(float &f) -

745 { -

746

&& floatingPointPrecision() == QDataStream::DoublePrecision) {

partially evaluated: version() >= QDataStream::Qt_4_6

TRUE	FALSE
yes Evaluation Count:38	no Evaluation Count:0

0-38

747

evaluated: floatingPointPrecision() == QDataStream::DoublePrecision

TRUE	FALSE
yes Evaluation Count:12	yes Evaluation Count:26

12-26

748

double d;

executed (the execution status of this line is deduced): double d;

749

*this >> d;

executed (the execution status of this line is deduced): *this >> d;

750

f = d;

executed (the execution status of this line is deduced): f = d;

751

executed: return *this;

Execution Count:12

752 } -

753 -

754

f = 0.0f;

executed (the execution status of this line is deduced): f = 0.0f;

755

if (dev->read((char *)&f, 4) != 4) {

never executed: return *this;

partially evaluated: !dev

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:26

0-26

756

evaluated: dev->read((char *)&f, 4) != 4

TRUE	FALSE
yes Evaluation Count:10	yes Evaluation Count:16

10-16

757

f = 0.0f;

executed (the execution status of this line is deduced): f = 0.0f;

758

executed (the execution status of this line is deduced): setStatus(ReadPastEnd);

759

executed: }

Execution Count:10

760

evaluated: !noswap

TRUE	FALSE
yes Evaluation Count:10	yes Evaluation Count:6

6-10

761

union {

executed (the execution status of this line is deduced): union {

762

float val1;

executed (the execution status of this line is deduced): float val1;

763

quint32 val2;

executed (the execution status of this line is deduced): quint32 val2;

764

x.val2 = qbswap(*reinterpret_cast<quint32 *>(&f));

executed (the execution status of this line is deduced): } x;

765

executed (the execution status of this line is deduced): x.val2 = qbswap(*reinterpret_cast<quint32 *>(&f));

766

f = x.val1;

executed (the execution status of this line is deduced): f = x.val1;

767

executed: }

Execution Count:10

768

executed: }

Execution Count:16

769

executed: return *this;

Execution Count:26

770 } -

771 -

772 /*! -

773 \overload -

774 -

775 Reads a floating point number from the stream into \a f, -

776 using the standard IEEE 754 format. Returns a reference to the -

777 stream. -

778 -

779 \sa setFloatingPointPrecision() -

780 */ -

781 -

782 QDataStream &QDataStream::operator>>(double &f) -

783 { -

784

&& floatingPointPrecision() == QDataStream::SinglePrecision) {

evaluated: version() >= QDataStream::Qt_4_6

TRUE	FALSE
yes Evaluation Count:4812	yes Evaluation Count:3220

3220-4812

785

evaluated: floatingPointPrecision() == QDataStream::SinglePrecision

TRUE	FALSE
yes Evaluation Count:1	yes Evaluation Count:4811

1-4811

786

float d;

executed (the execution status of this line is deduced): float d;

787

*this >> d;

executed (the execution status of this line is deduced): *this >> d;

788

f = d;

executed (the execution status of this line is deduced): f = d;

789

executed: return *this;

Execution Count:1

790 } -

791 -

792

f = 0.0;

executed (the execution status of this line is deduced): f = 0.0;

793

if (dev->read((char *)&f, 8) != 8) {

never executed: return *this;

partially evaluated: !dev

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:8031

0-8031

794

evaluated: dev->read((char *)&f, 8) != 8

TRUE	FALSE
yes Evaluation Count:46	yes Evaluation Count:7985

46-7985

795

f = 0.0;

executed (the execution status of this line is deduced): f = 0.0;

796

executed (the execution status of this line is deduced): setStatus(ReadPastEnd);

797

executed: }

Execution Count:46

798

evaluated: !noswap

TRUE	FALSE
yes Evaluation Count:7978	yes Evaluation Count:7

7-7978

799

union {

executed (the execution status of this line is deduced): union {

800

double val1;

executed (the execution status of this line is deduced): double val1;

801

quint64 val2;

executed (the execution status of this line is deduced): quint64 val2;

802

x.val2 = qbswap(*reinterpret_cast<quint64 *>(&f));

executed (the execution status of this line is deduced): } x;

803

executed (the execution status of this line is deduced): x.val2 = qbswap(*reinterpret_cast<quint64 *>(&f));

804

f = x.val1;

executed (the execution status of this line is deduced): f = x.val1;

805

executed: }

Execution Count:7978

7978

806

executed: }

Execution Count:7985

7985

807

return readBytes(s, len);

executed: return *this;

Execution Count:8031

8031

808 } -

809 -

810 -

811 /*! -

812 \overload -

813 -

814 Reads the '\\0'-terminated string \a s from the stream and returns -

815 a reference to the stream. -

816 -

817 Space for the string is allocated using \c new -- the caller must -

818 destroy it with \c{delete[]}. -

819 */ -

820 -

821 QDataStream &QDataStream::operator>>(char *&s) -

822 { -

823

uint len = 0;

executed (the execution status of this line is deduced): uint len = 0;

824

executed: return readBytes(s, len);

Execution Count:28

825 } -

826 -

827 -

828 /*! -

829 Reads the buffer \a s from the stream and returns a reference to -

830 the stream. -

831 -

832 The buffer \a s is allocated using \c new. Destroy it with the \c -

833 delete[] operator. -

834 -

835 The \a l parameter is set to the length of the buffer. If the -

836 string read is empty, \a l is set to 0 and \a s is set to -

837 a null pointer. -

838 -

839 The serialization format is a quint32 length specifier first, -

840 then \a l bytes of data. -

841 -

842 \sa readRawData(), writeBytes() -

843 */ -

844 -

845 QDataStream &QDataStream::readBytes(char *&s, uint &l) -

846 { -

847

s = 0;

executed (the execution status of this line is deduced): s = 0;

848

l = 0;

executed (the execution status of this line is deduced): l = 0;

849

never executed: return *this;

partially evaluated: !dev

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:56

0-56

850 -

851

quint32 len;

executed (the execution status of this line is deduced): quint32 len;

852

*this >> len;

executed (the execution status of this line is deduced): *this >> len;

853

if (len == 0)

evaluated: len == 0

TRUE	FALSE
yes Evaluation Count:10	yes Evaluation Count:46

10-46

854

const quint32 Step = 1024 * 1024;

executed: return *this;

Execution Count:10

855 -

856

executed (the execution status of this line is deduced): const quint32 Step = 1024 * 1024;

857

quint32 allocated = 0;

executed (the execution status of this line is deduced): quint32 allocated = 0;

858

char *prevBuf = 0;

executed (the execution status of this line is deduced): char *prevBuf = 0;

859

char *curBuf = 0;

executed (the execution status of this line is deduced): char *curBuf = 0;

860 -

861 do { -

862

int blockSize = qMin(Step, len - allocated);

executed (the execution status of this line is deduced): int blockSize = qMin(Step, len - allocated);

863

prevBuf = curBuf;

executed (the execution status of this line is deduced): prevBuf = curBuf;

864

curBuf = new char[allocated + blockSize + 1];

executed (the execution status of this line is deduced): curBuf = new char[allocated + blockSize + 1];

865

if (prevBuf) {

evaluated: prevBuf

TRUE	FALSE
yes Evaluation Count:28	yes Evaluation Count:46

28-46

866

memcpy(curBuf, prevBuf, allocated);

executed (the execution status of this line is deduced): memcpy(curBuf, prevBuf, allocated);

867

delete [] prevBuf;

executed (the execution status of this line is deduced): delete [] prevBuf;

868

if (dev->read(curBuf + allocated, blockSize) != blockSize) {

executed: }

Execution Count:28

869

evaluated: dev->read(curBuf + allocated, blockSize) != blockSize

TRUE	FALSE
yes Evaluation Count:24	yes Evaluation Count:50

24-50

870

delete [] curBuf;

executed (the execution status of this line is deduced): delete [] curBuf;

871

executed (the execution status of this line is deduced): setStatus(ReadPastEnd);

872

} while (allocated < len);

executed: return *this;

Execution Count:24

873 } -

874

allocated += blockSize;

executed (the execution status of this line is deduced): allocated += blockSize;

875

executed: }

Execution Count:50

evaluated: allocated < len

TRUE	FALSE
yes Evaluation Count:28	yes Evaluation Count:22

22-50

876 -

877

s = curBuf;

executed (the execution status of this line is deduced): s = curBuf;

878

s[len] = '\0';

executed (the execution status of this line is deduced): s[len] = '\0';

879

l = (uint)len;

executed (the execution status of this line is deduced): l = (uint)len;

880

return dev->read(s, len);

executed: return *this;

Execution Count:22

881 } -

882 -

883 /*! -

884 Reads at most \a len bytes from the stream into \a s and returns the number of -

885 bytes read. If an error occurs, this function returns -1. -

886 -

887 The buffer \a s must be preallocated. The data is \e not encoded. -

888 -

889 \sa readBytes(), QIODevice::read(), writeRawData() -

890 */ -

891 -

892 int QDataStream::readRawData(char *s, int len) -

893 { -

894

CHECK_STREAM_PRECOND(-1)

never executed: return -1;

partially evaluated: !dev

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:15407

0-15407

895

executed: return dev->read(s, len);

Execution Count:15407

15407

896 } -

897 -

898 -

899 /***************************************************************************** -

900 QDataStream write functions -

901 *****************************************************************************/ -

902 -

903 -

904 /*! -

905 \fn QDataStream &QDataStream::operator<<(quint8 i) -

906 \overload -

907 -

908 Writes an unsigned byte, \a i, to the stream and returns a -

909 reference to the stream. -

910 */ -

911 -

912 /*! -

913 Writes a signed byte, \a i, to the stream and returns a reference -

914 to the stream. -

915 */ -

916 -

917 QDataStream &QDataStream::operator<<(qint8 i) -

918 { -

919

never executed: return *this;

executed: return *this;

Execution Count:2

partially evaluated: !dev

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:16668

evaluated: q_status != Ok

TRUE	FALSE
yes Evaluation Count:2	yes Evaluation Count:16666

0-16668

920

if (!dev->putChar(i))

evaluated: !dev->putChar(i)

TRUE	FALSE
yes Evaluation Count:2	yes Evaluation Count:16664

2-16664

921

executed: q_status = WriteFailed;

Execution Count:2

922

executed: return *this;

Execution Count:16666

16666

923 } -

924 -

925 -

926 /*! -

927 \fn QDataStream &QDataStream::operator<<(quint16 i) -

928 \overload -

929 -

930 Writes an unsigned 16-bit integer, \a i, to the stream and returns -

931 a reference to the stream. -

932 */ -

933 -

934 /*! -

935 \overload -

936 -

937 Writes a signed 16-bit integer, \a i, to the stream and returns a -

938 reference to the stream. -

939 */ -

940 -

941 QDataStream &QDataStream::operator<<(qint16 i) -

942 { -

943

never executed: return *this;

executed: return *this;

Execution Count:2

partially evaluated: !dev

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:5757

evaluated: q_status != Ok

TRUE	FALSE
yes Evaluation Count:2	yes Evaluation Count:5755

0-5757

944

evaluated: !noswap

TRUE	FALSE
yes Evaluation Count:5627	yes Evaluation Count:128

128-5627

945

executed (the execution status of this line is deduced): i = qbswap(i);

946

if (dev->write((char *)&i, sizeof(qint16)) != sizeof(qint16))

executed: }

Execution Count:5627

5627

947

evaluated: dev->write((char *)&i, sizeof(qint16)) != sizeof(qint16)

TRUE	FALSE
yes Evaluation Count:2	yes Evaluation Count:5753

2-5753

948

executed: q_status = WriteFailed;

Execution Count:2

949

executed: return *this;

Execution Count:5755

5755

950 } -

951 -

952 /*! -

953 \overload -

954 -

955 Writes a signed 32-bit integer, \a i, to the stream and returns a -

956 reference to the stream. -

957 */ -

958 -

959 QDataStream &QDataStream::operator<<(qint32 i) -

960 { -

961

never executed: return *this;

executed: return *this;

Execution Count:3

partially evaluated: !dev

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:53180

evaluated: q_status != Ok

TRUE	FALSE
yes Evaluation Count:3	yes Evaluation Count:53177

0-53180

962

evaluated: !noswap

TRUE	FALSE
yes Evaluation Count:52825	yes Evaluation Count:352

352-52825

963

executed (the execution status of this line is deduced): i = qbswap(i);

964

if (dev->write((char *)&i, sizeof(qint32)) != sizeof(qint32))

executed: }

Execution Count:52825

52825

965

evaluated: dev->write((char *)&i, sizeof(qint32)) != sizeof(qint32)

TRUE	FALSE
yes Evaluation Count:3	yes Evaluation Count:53174

3-53174

966

executed: q_status = WriteFailed;

Execution Count:3

967

executed: return *this;

Execution Count:53177

53177

968 } -

969 -

970 /*! -

971 \fn QDataStream &QDataStream::operator<<(quint64 i) -

972 \overload -

973 -

974 Writes an unsigned 64-bit integer, \a i, to the stream and returns a -

975 reference to the stream. -

976 */ -

977 -

978 /*! -

979 \overload -

980 -

981 Writes a signed 64-bit integer, \a i, to the stream and returns a -

982 reference to the stream. -

983 */ -

984 -

985 QDataStream &QDataStream::operator<<(qint64 i) -

986 { -

987

quint32 i1 = i & 0xffffffff;

never executed: return *this;

executed: return *this;

Execution Count:2

partially evaluated: !dev

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:536

evaluated: q_status != Ok

TRUE	FALSE
yes Evaluation Count:2	yes Evaluation Count:534

0-536

988

if (version() < 6) {

partially evaluated: version() < 6

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:534

0-534

989

never executed (the execution status of this line is deduced): quint32 i1 = i & 0xffffffff;

990

quint32 i2 = i >> 32;

never executed (the execution status of this line is deduced): quint32 i2 = i >> 32;

991

*this << i2 << i1;

never executed (the execution status of this line is deduced): *this << i2 << i1;

never executed: }

partially evaluated: !noswap

TRUE	FALSE
yes Evaluation Count:534	no Evaluation Count:0

0-534

994

executed (the execution status of this line is deduced): i = qbswap(i);

995

if (dev->write((char *)&i, sizeof(qint64)) != sizeof(qint64))

executed: }

Execution Count:534

534

996

evaluated: dev->write((char *)&i, sizeof(qint64)) != sizeof(qint64)

TRUE	FALSE
yes Evaluation Count:2	yes Evaluation Count:532

2-532

997

executed: q_status = WriteFailed;

Execution Count:2

998

executed: }

Execution Count:534

534

999

executed: return *this;

Execution Count:534

534

1000 } -

1001 -

1002 /*! -

1003 \fn QDataStream &QDataStream::operator<<(quint32 i) -

1004 \overload -

1005 -

1006 Writes an unsigned integer, \a i, to the stream as a 32-bit -

1007 unsigned integer (quint32). Returns a reference to the stream. -

1008 */ -

1009 -

1010 /*! -

1011 Writes a boolean value, \a i, to the stream. Returns a reference -

1012 to the stream. -

1013 */ -

1014 -

1015 QDataStream &QDataStream::operator<<(bool i) -

1016 { -

1017

if (!dev->putChar(qint8(i)))

never executed: return *this;

executed: return *this;

Execution Count:1

partially evaluated: !dev

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:1966

evaluated: q_status != Ok

TRUE	FALSE
yes Evaluation Count:1	yes Evaluation Count:1965

0-1966

1018

evaluated: !dev->putChar(qint8(i))

TRUE	FALSE
yes Evaluation Count:1	yes Evaluation Count:1964

1-1964

1019

executed: q_status = WriteFailed;

Execution Count:1

1020

executed: return *this;

Execution Count:1965

1965

1021 } -

1022 -

1023 /*! -

1024 \overload -

1025 -

1026 Writes a floating point number, \a f, to the stream using -

1027 the standard IEEE 754 format. Returns a reference to the stream. -

1028 -

1029 \sa setFloatingPointPrecision() -

1030 */ -

1031 -

1032 QDataStream &QDataStream::operator<<(float f) -

1033 { -

1034

&& floatingPointPrecision() == QDataStream::DoublePrecision) {

partially evaluated: version() >= QDataStream::Qt_4_6

TRUE	FALSE
yes Evaluation Count:14	no Evaluation Count:0

0-14

1035

evaluated: floatingPointPrecision() == QDataStream::DoublePrecision

TRUE	FALSE
yes Evaluation Count:10	yes Evaluation Count:4

4-10

1036

*this << double(f);

executed (the execution status of this line is deduced): *this << double(f);

1037

executed: return *this;

Execution Count:10

1038 } -

1039 -

1040

float g = f; // fixes float-on-stack problem

never executed: return *this;

partially evaluated: !dev

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:4

partially evaluated: q_status != Ok

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:4

0-4

1041

executed (the execution status of this line is deduced): float g = f;

1042

partially evaluated: !noswap

TRUE	FALSE
yes Evaluation Count:4	no Evaluation Count:0

0-4

1043

union {

executed (the execution status of this line is deduced): union {

1044

float val1;

executed (the execution status of this line is deduced): float val1;

1045

quint32 val2;

executed (the execution status of this line is deduced): quint32 val2;

1046

if (dev->write((char *)&x.val2, sizeof(float)) != sizeof(float))

executed (the execution status of this line is deduced): } x;

1047

x.val1 = g;

executed (the execution status of this line is deduced): x.val1 = g;

1048

x.val2 = qbswap(x.val2);

executed (the execution status of this line is deduced): x.val2 = qbswap(x.val2);

1049 -

1050

partially evaluated: dev->write((char *)&x.val2, sizeof(float)) != sizeof(float)

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:4

0-4

1051

never executed: q_status = WriteFailed;

1052

if (dev->write((char *)&g, sizeof(float)) != sizeof(float))

executed: return *this;

Execution Count:4

1053 } -

1054 -

1055

never evaluated: dev->write((char *)&g, sizeof(float)) != sizeof(float)

1056

never executed: q_status = WriteFailed;

1057

never executed: return *this;

1058 } -

1059 -

1060 -

1061 /*! -

1062 \overload -

1063 -

1064 Writes a floating point number, \a f, to the stream using -

1065 the standard IEEE 754 format. Returns a reference to the stream. -

1066 -

1067 \sa setFloatingPointPrecision() -

1068 */ -

1069 -

1070 QDataStream &QDataStream::operator<<(double f) -

1071 { -

1072

&& floatingPointPrecision() == QDataStream::SinglePrecision) {

evaluated: version() >= QDataStream::Qt_4_6

TRUE	FALSE
yes Evaluation Count:4728	yes Evaluation Count:3607

3607-4728

1073

evaluated: floatingPointPrecision() == QDataStream::SinglePrecision

TRUE	FALSE
yes Evaluation Count:1	yes Evaluation Count:4727

1-4727

1074

*this << float(f);

executed (the execution status of this line is deduced): *this << float(f);

1075

executed: return *this;

Execution Count:1

1076 } -

1077 -

1078

if (dev->write((char *)&f, sizeof(double)) != sizeof(double))

never executed: return *this;

executed: return *this;

Execution Count:2

partially evaluated: !dev

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:8334

evaluated: q_status != Ok

TRUE	FALSE
yes Evaluation Count:2	yes Evaluation Count:8332

0-8334

1079

if (noswap) {

partially evaluated: noswap

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:8332

0-8332

1080

never evaluated: dev->write((char *)&f, sizeof(double)) != sizeof(double)

1081

never executed: q_status = WriteFailed;

never executed: }

executed (the execution status of this line is deduced): union {

1084

double val1;

executed (the execution status of this line is deduced): double val1;

1085

quint64 val2;

executed (the execution status of this line is deduced): quint64 val2;

1086

if (dev->write((char *)&x.val2, sizeof(double)) != sizeof(double))

executed (the execution status of this line is deduced): } x;

1087

x.val1 = f;

executed (the execution status of this line is deduced): x.val1 = f;

1088

x.val2 = qbswap(x.val2);

executed (the execution status of this line is deduced): x.val2 = qbswap(x.val2);

1089

evaluated: dev->write((char *)&x.val2, sizeof(double)) != sizeof(double)

TRUE	FALSE
yes Evaluation Count:2	yes Evaluation Count:8330

2-8330

1090

executed: q_status = WriteFailed;

Execution Count:2

1091

executed: }

Execution Count:8332

8332

1092

executed: return *this;

Execution Count:8332

8332

1093 } -

1094 -

1095 -

1096 /*! -

1097 \overload -

1098 -

1099 Writes the '\\0'-terminated string \a s to the stream and returns a -

1100 reference to the stream. -

1101 -

1102 The string is serialized using writeBytes(). -

1103 */ -

1104 -

1105 QDataStream &QDataStream::operator<<(const char *s) -

1106 { -

1107

if (!s) {

partially evaluated: !s

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:4

0-4

1108

*this << (quint32)0;

never executed (the execution status of this line is deduced): *this << (quint32)0;

1109

uint len = qstrlen(s) + 1; // also write null terminator

never executed: return *this;

1110 } -

1111

executed (the execution status of this line is deduced): uint len = qstrlen(s) + 1;

1112

*this << (quint32)len; // write length specifier

executed (the execution status of this line is deduced): *this << (quint32)len;

1113

writeRawData(s, len);

executed (the execution status of this line is deduced): writeRawData(s, len);

1114

executed: return *this;

Execution Count:4

1115 } -

1116 -

1117 -

1118 /*! -

1119 Writes the length specifier \a len and the buffer \a s to the -

1120 stream and returns a reference to the stream. -

1121 -

1122 The \a len is serialized as a quint32, followed by \a len bytes -

1123 from \a s. Note that the data is \e not encoded. -

1124 -

1125 \sa writeRawData(), readBytes() -

1126 */ -

1127 -

1128 QDataStream &QDataStream::writeBytes(const char *s, uint len) -

1129 { -

1130

*this << (quint32)len; // write length specifier

never executed: return *this;

partially evaluated: !dev

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:15342

partially evaluated: q_status != Ok

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:15342

0-15342

1131

executed (the execution status of this line is deduced): *this << (quint32)len;

1132

if (len)

evaluated: len

TRUE	FALSE
yes Evaluation Count:15121	yes Evaluation Count:221

221-15121

1133

writeRawData(s, len);

executed: writeRawData(s, len);

Execution Count:15121

15121

1134

CHECK_STREAM_WRITE_PRECOND(-1)

executed: return *this;

Execution Count:15342

15342

1135 } -

1136 -

1137 -

1138 /*! -

1139 Writes \a len bytes from \a s to the stream. Returns the -

1140 number of bytes actually written, or -1 on error. -

1141 The data is \e not encoded. -

1142 -

1143 \sa writeBytes(), QIODevice::write(), readRawData() -

1144 */ -

1145 -

1146 int QDataStream::writeRawData(const char *s, int len) -

1147 { -

1148

never executed: return -1;

executed: return -1;

Execution Count:3

partially evaluated: !dev

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:16514

evaluated: q_status != Ok

TRUE	FALSE
yes Evaluation Count:3	yes Evaluation Count:16511

0-16514

1149

int ret = dev->write(s, len);

executed (the execution status of this line is deduced): int ret = dev->write(s, len);

1150

if (ret != len)

evaluated: ret != len

TRUE	FALSE
yes Evaluation Count:1	yes Evaluation Count:16510

1-16510

1151

if (dev->isSequential()) {

executed: q_status = WriteFailed;

Execution Count:1

1152

return ret;

executed: return ret;

Execution Count:16511

16511

1153 } -

1154 -

1155 /*! -

1156 \since 4.1 -

1157 -

1158 Skips \a len bytes from the device. Returns the number of bytes -

1159 actually skipped, or -1 on error. -

1160 -

1161 This is equivalent to calling readRawData() on a buffer of length -

1162 \a len and ignoring the buffer. -

1163 -

1164 \sa QIODevice::seek() -

1165 */ -

1166 int QDataStream::skipRawData(int len) -

1167 { -

1168

CHECK_STREAM_PRECOND(-1)

never executed: return -1;

partially evaluated: !dev

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:6

0-6

1169 -

1170

evaluated: dev->isSequential()

TRUE	FALSE
yes Evaluation Count:3	yes Evaluation Count:3

1171

char buf[4096];

executed (the execution status of this line is deduced): char buf[4096];

1172

int sumRead = 0;

executed (the execution status of this line is deduced): int sumRead = 0;

1173 -

1174

while (len > 0) {

evaluated: len > 0

TRUE	FALSE
yes Evaluation Count:9	yes Evaluation Count:3

3-9

1175

int blockSize = qMin(len, (int)sizeof(buf));

executed (the execution status of this line is deduced): int blockSize = qMin(len, (int)sizeof(buf));

1176

int n = dev->read(buf, blockSize);

executed (the execution status of this line is deduced): int n = dev->read(buf, blockSize);

1177

if (n == -1)

partially evaluated: n == -1

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:9

0-9

1178

return -1;

never executed: return -1;

1179

if (n == 0)

partially evaluated: n == 0

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:9

0-9

1180

return sumRead;

never executed: return sumRead;

1181 -

1182

sumRead += n;

executed (the execution status of this line is deduced): sumRead += n;

1183

len -= blockSize;

executed (the execution status of this line is deduced): len -= blockSize;

1184