qnoncontiguousbytedevice.cpp

Jenkins

Absolute File Name:

/home/qt/qt5_coco/qt5/qtbase/src/corelib/io/qnoncontiguousbytedevice.cpp

Line

Source

Count

/****************************************************************************

** Contact: https://www.qt.io/licensing/

** This file is part of the QtCore module of the Qt Toolkit.

** $QT_BEGIN_LICENSE:LGPL$

** Commercial License Usage

** Licensees holding valid commercial Qt licenses may use this file in

** accordance with the commercial license agreement provided with the

** Software or, alternatively, in accordance with the terms contained in

** a written agreement between you and The Qt Company. For licensing terms

** and conditions see https://www.qt.io/terms-conditions. For further

** information use the contact form at https://www.qt.io/contact-us.

** GNU Lesser General Public License Usage

** Alternatively, this file may be used under the terms of the GNU Lesser

** General Public License version 3 as published by the Free Software

** Foundation and appearing in the file LICENSE.LGPL3 included in the

** packaging of this file. Please review the following information to

** ensure the GNU Lesser General Public License version 3 requirements

** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.

** GNU General Public License Usage

** Alternatively, this file may be used under the terms of the GNU

** General Public License version 2.0 or (at your option) the GNU General

** Public license version 3 or any later version approved by the KDE Free

** Qt Foundation. The licenses are as published by the Free Software

** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3

** included in the packaging of this file. Please review the following

** information to ensure the GNU General Public License requirements will

** be met: https://www.gnu.org/licenses/gpl-2.0.html and

** https://www.gnu.org/licenses/gpl-3.0.html.

** $QT_END_LICENSE$

****************************************************************************/

#include "qnoncontiguousbytedevice_p.h"

#include <qbuffer.h>

#include <qdebug.h>

#include <qfile.h>

QT_BEGIN_NAMESPACE

/*!

\class QNonContiguousByteDevice

\inmodule QtCore

\brief A QNonContiguousByteDevice is a representation of a

file, array or buffer that allows access with a read pointer.

\since 4.6

The goal of this class is to have a data representation that

allows us to avoid doing a memcpy as we have to do with QIODevice.

\sa QNonContiguousByteDeviceFactory

\internal

/*!

\fn virtual const char* QNonContiguousByteDevice::readPointer(qint64 maximumLength, qint64 &len)

Return a byte pointer for at most \a maximumLength bytes of that device.

if \a maximumLength is -1, the caller does not care about the length and

the device may return what it desires to.

The actual number of bytes the pointer is valid for is returned in

the \a len variable.

\a len will be -1 if EOF or an error occurs.

If it was really EOF can then afterwards be checked with atEnd()

Returns 0 if it is not possible to read at that position.

\sa atEnd()

\internal

/*!

\fn virtual bool QNonContiguousByteDevice::advanceReadPointer(qint64 amount)

will advance the internal read pointer by \a amount bytes.

The old readPointer is invalid after this call.

\sa readPointer()

\internal

/*!

\fn virtual bool QNonContiguousByteDevice::atEnd() const

Returns \c true if everything has been read and the read

pointer cannot be advanced anymore.

\sa readPointer(), advanceReadPointer(), reset()

\internal

/*!

\fn virtual bool QNonContiguousByteDevice::reset()

100

Moves the internal read pointer back to the beginning.

101

Returns \c false if this was not possible.

\sa atEnd()

\internal

/*!

\fn virtual qint64 QNonContiguousByteDevice::size() const

109

110

Returns the size of the complete device or -1 if unknown.

111

May also return less/more than what can be actually read with readPointer()

\internal

/*!

\fn void QNonContiguousByteDevice::readyRead()

117

118

Emitted when there is data available

\internal

/*!

\fn void QNonContiguousByteDevice::readProgress(qint64 current, qint64 total)

124

125

Emitted when data has been "read" by advancing the read pointer

\internal

QNonContiguousByteDevice::QNonContiguousByteDevice() : QObject((QObject*)0)

{

}

QNonContiguousByteDevice::~QNonContiguousByteDevice()

{

}

// FIXME we should scrap this whole implementation and instead change the ByteArrayImpl to be able to cope with sub-arrays?

139

QNonContiguousByteDeviceBufferImpl::QNonContiguousByteDeviceBufferImpl(QBuffer *b) : QNonContiguousByteDevice()

140

{

141

buffer = b;

142

byteArray = QByteArray::fromRawData(buffer->buffer().constData() + buffer->pos(), buffer->size() - buffer->pos());

143

arrayImpl = new QNonContiguousByteDeviceByteArrayImpl(&byteArray);

144

arrayImpl->setParent(this);

145

connect(arrayImpl, SIGNAL(readyRead()), SIGNAL(readyRead()));

146

connect(arrayImpl, SIGNAL(readProgress(qint64,qint64)), SIGNAL(readProgress(qint64,qint64)));

147

}

148

149

QNonContiguousByteDeviceBufferImpl::~QNonContiguousByteDeviceBufferImpl()

{

}

const char* QNonContiguousByteDeviceBufferImpl::readPointer(qint64 maximumLength, qint64 &len)

154

{

155

return arrayImpl->readPointer(maximumLength, len);

156

}

157

158

bool QNonContiguousByteDeviceBufferImpl::advanceReadPointer(qint64 amount)

159

{

160

return arrayImpl->advanceReadPointer(amount);

161

}

162

163

bool QNonContiguousByteDeviceBufferImpl::atEnd() const

164

{

165

return arrayImpl->atEnd();

executed 1051 times by 3 tests: return arrayImpl->atEnd();

Executed by:

tst_QNetworkReply
tst_QXmlInputSource
tst_Spdy

1051

166

}

167

168

bool QNonContiguousByteDeviceBufferImpl::reset()

169

{

170

return arrayImpl->reset();

171

}

172

173

qint64 QNonContiguousByteDeviceBufferImpl::size() const

174

{

175

return arrayImpl->size();

executed 1100 times by 3 tests: return arrayImpl->size();

Executed by:

tst_QNetworkReply
tst_QXmlInputSource
tst_Spdy

1100

176

}

177

178

QNonContiguousByteDeviceByteArrayImpl::QNonContiguousByteDeviceByteArrayImpl(QByteArray *ba) : QNonContiguousByteDevice(), currentPosition(0)

{

byteArray = ba;

}

QNonContiguousByteDeviceByteArrayImpl::~QNonContiguousByteDeviceByteArrayImpl()

{

}

const char* QNonContiguousByteDeviceByteArrayImpl::readPointer(qint64 maximumLength, qint64 &len)

{

if (atEnd()) {

len = -1;

return 0;

}

if (maximumLength != -1)

195

len = qMin(maximumLength, size() - currentPosition);

196

else

197

len = size() - currentPosition;

198

199

return byteArray->constData() + currentPosition;

200

}

201

202

bool QNonContiguousByteDeviceByteArrayImpl::advanceReadPointer(qint64 amount)

203

{

204

currentPosition += amount;

205

emit readProgress(currentPosition, size());

return true;

}

bool QNonContiguousByteDeviceByteArrayImpl::atEnd() const

210

{

211

return currentPosition >= size();

executed 2361 times by 4 tests: return currentPosition >= size();

Executed by:

tst_QHttpNetworkConnection
tst_QNetworkReply
tst_QXmlInputSource
tst_Spdy

2361

212

}

213

214

bool QNonContiguousByteDeviceByteArrayImpl::reset()

{

currentPosition = 0;

return true;

}

qint64 QNonContiguousByteDeviceByteArrayImpl::size() const

221

{

222

return byteArray->size();

executed 6023 times by 4 tests: return byteArray->size();

Executed by:

tst_QHttpNetworkConnection
tst_QNetworkReply
tst_QXmlInputSource
tst_Spdy

6023

223

}

224

225

qint64 QNonContiguousByteDeviceByteArrayImpl::pos() const

226

{

227

return currentPosition;

executed 4 times by 1 test: return currentPosition;

Executed by:

tst_QHttpNetworkConnection

228

}

229

230

QNonContiguousByteDeviceRingBufferImpl::QNonContiguousByteDeviceRingBufferImpl(QSharedPointer<QRingBuffer> rb)

231

: QNonContiguousByteDevice(), currentPosition(0)

{

ringBuffer = rb;

}

QNonContiguousByteDeviceRingBufferImpl::~QNonContiguousByteDeviceRingBufferImpl()

{

}

const char* QNonContiguousByteDeviceRingBufferImpl::readPointer(qint64 maximumLength, qint64 &len)

{

if (atEnd()) {

len = -1;

return 0;

}

const char *returnValue = ringBuffer->readPointerAtPosition(currentPosition, len);

248

249

if (maximumLength != -1)

250

len = qMin(len, maximumLength);

return returnValue;

}

bool QNonContiguousByteDeviceRingBufferImpl::advanceReadPointer(qint64 amount)

256

{

257

currentPosition += amount;

258

emit readProgress(currentPosition, size());

return true;

}

bool QNonContiguousByteDeviceRingBufferImpl::atEnd() const

263

{

264

return currentPosition >= size();

executed 1126 times by 1 test: return currentPosition >= size();

Executed by:

tst_QNetworkReply

1126

265

}

266

267

qint64 QNonContiguousByteDeviceRingBufferImpl::pos() const

268

{

269

return currentPosition;

executed 716 times by 1 test: return currentPosition;

Executed by:

tst_QNetworkReply

716

270

}

271

272

bool QNonContiguousByteDeviceRingBufferImpl::reset()

{

currentPosition = 0;

return true;

}

qint64 QNonContiguousByteDeviceRingBufferImpl::size() const

279

{

280

return ringBuffer->size();

executed 2293 times by 1 test: return ringBuffer->size();

Executed by:

tst_QNetworkReply

2293

281

}

282

283

QNonContiguousByteDeviceIoDeviceImpl::QNonContiguousByteDeviceIoDeviceImpl(QIODevice *d)

284

: QNonContiguousByteDevice(),

285

currentReadBuffer(0), currentReadBufferSize(16*1024),

286

currentReadBufferAmount(0), currentReadBufferPosition(0), totalAdvancements(0),

eof(false)

{

device = d;

initialPosition = d->pos();

291

connect(device, SIGNAL(readyRead()), this, SIGNAL(readyRead()), Qt::QueuedConnection);

292

connect(device, SIGNAL(readChannelFinished()), this, SIGNAL(readyRead()), Qt::QueuedConnection);

293

}

294

295

QNonContiguousByteDeviceIoDeviceImpl::~QNonContiguousByteDeviceIoDeviceImpl()

296

{

297

delete currentReadBuffer;

298

}

299

300

const char* QNonContiguousByteDeviceIoDeviceImpl::readPointer(qint64 maximumLength, qint64 &len)

{

if (eof == true) {

len = -1;

return 0;

}

if (currentReadBuffer == 0)

308

currentReadBuffer = new QByteArray(currentReadBufferSize, '\0'); // lazy alloc

309

310

if (maximumLength == -1)

311

maximumLength = currentReadBufferSize;

312

313

if (currentReadBufferAmount - currentReadBufferPosition > 0) {

314

len = currentReadBufferAmount - currentReadBufferPosition;

315

return currentReadBuffer->data() + currentReadBufferPosition;

316

}

317

318

qint64 haveRead = device->read(currentReadBuffer->data(), qMin(maximumLength, currentReadBufferSize));

319

320

if ((haveRead == -1) || (haveRead == 0 && device->atEnd() && !device->isSequential())) {

321

eof = true;

322

len = -1;

323

// size was unknown before, emit a readProgress with the final size

324

if (size() == -1)

325

emit readProgress(totalAdvancements, totalAdvancements);

return 0;

}

currentReadBufferAmount = haveRead;

330

currentReadBufferPosition = 0;

331

332

len = haveRead;

333

return currentReadBuffer->data();

334

}

335

336

bool QNonContiguousByteDeviceIoDeviceImpl::advanceReadPointer(qint64 amount)

337

{

338

totalAdvancements += amount;

339

340

// normal advancement

341

currentReadBufferPosition += amount;

342

343

if (size() == -1)

344

emit readProgress(totalAdvancements, totalAdvancements);

345

else

346

emit readProgress(totalAdvancements, size());

347

348

// advancing over that what has actually been read before

349

if (currentReadBufferPosition > currentReadBufferAmount) {

350

qint64 i = currentReadBufferPosition - currentReadBufferAmount;

351

while (i > 0) {

352

if (device->getChar(0) == false) {

353

emit readProgress(totalAdvancements - i, size());

354

return false; // ### FIXME handle eof

}

i--;

}

currentReadBufferPosition = 0;

360

currentReadBufferAmount = 0;

}

return true;

}

bool QNonContiguousByteDeviceIoDeviceImpl::atEnd() const

368

{

369

return eof == true;

executed 1580 times by 2 tests: return eof == true;

Executed by:

tst_QNetworkReply
tst_Spdy

1580

370

}

371

372

bool QNonContiguousByteDeviceIoDeviceImpl::reset()

373

{

374

bool reset = (initialPosition == 0) ? device->reset() : device->seek(initialPosition);

375

if (reset) {

376

eof = false; // assume eof is false, it will be true after a read has been attempted

377

totalAdvancements = 0; //reset the progress counter

378

if (currentReadBuffer) {

379

delete currentReadBuffer;

380

currentReadBuffer = 0;

381

}

382

currentReadBufferAmount = 0;

383

currentReadBufferPosition = 0;

return true;

}

return false;

}

qint64 QNonContiguousByteDeviceIoDeviceImpl::size() const

391

{

392

// note that this is different from the size() implementation of QIODevice!

393

394

if (device->isSequential())

device->isSequential()	Description
TRUE	evaluated 607 times by 1 test Evaluated by: tst_QNetworkReply
FALSE	evaluated 4707 times by 2 tests Evaluated by: tst_QNetworkReply tst_Spdy

607-4707

395

return -1;

executed 607 times by 1 test: return -1;

Executed by:

tst_QNetworkReply

607

396

397

return device->size() - initialPosition;

executed 4707 times by 2 tests: return device->size() - initialPosition;

Executed by:

tst_QNetworkReply
tst_Spdy

4707

398

}

399

400

qint64 QNonContiguousByteDeviceIoDeviceImpl::pos() const

401

{

402

if (device->isSequential())

device->isSequential()	Description
TRUE	never evaluated
FALSE	never evaluated

403

return -1;

never executed: return -1;

404

405

return device->pos();

never executed: return device->pos();

406

}

407

408

QByteDeviceWrappingIoDevice::QByteDeviceWrappingIoDevice(QNonContiguousByteDevice *bd) : QIODevice((QObject*)0)

409

{

410

byteDevice = bd;

411

connect(bd, SIGNAL(readyRead()), SIGNAL(readyRead()));

open(ReadOnly);

}

QByteDeviceWrappingIoDevice::~QByteDeviceWrappingIoDevice()

{

}

bool QByteDeviceWrappingIoDevice::isSequential() const

422

{

423

return (byteDevice->size() == -1);

424

}

425

426

bool QByteDeviceWrappingIoDevice::atEnd() const

427

{

428

return byteDevice->atEnd();

429

}

430

431

bool QByteDeviceWrappingIoDevice::reset()

432

{

433

return byteDevice->reset();

434

}

435

436

qint64 QByteDeviceWrappingIoDevice::size() const

{

if (isSequential())

return 0;

return byteDevice->size();

}

qint64 QByteDeviceWrappingIoDevice::readData( char * data, qint64 maxSize)

446

{

447

qint64 len;

448

const char *readPointer = byteDevice->readPointer(maxSize, len);

if (len == -1)

return -1;

memcpy(data, readPointer, len);

453

byteDevice->advanceReadPointer(len);

return len;

}

qint64 QByteDeviceWrappingIoDevice::writeData( const char* data, qint64 maxSize)

{

Q_UNUSED(data);

Q_UNUSED(maxSize);

return -1;

}

/*!

\class QNonContiguousByteDeviceFactory

\inmodule QtCore

\since 4.6

Creates a QNonContiguousByteDevice out of a QIODevice,

470

QByteArray etc.

471

472

\sa QNonContiguousByteDevice

\internal

/*!

\fn static QNonContiguousByteDevice* QNonContiguousByteDeviceFactory::create(QIODevice *device)

479

480

Create a QNonContiguousByteDevice out of a QIODevice.

481

For QFile, QBuffer and all other QIoDevice, sequential or not.

\internal

QNonContiguousByteDevice* QNonContiguousByteDeviceFactory::create(QIODevice *device)

486

{

487

// shortcut if it is a QBuffer

488

if (QBuffer* buffer = qobject_cast<QBuffer*>(device)) {

489

return new QNonContiguousByteDeviceBufferImpl(buffer);

490

}

491

492

// ### FIXME special case if device is a QFile that supports map()

493

// then we can actually deal with the file without using read/peek

494

495

// generic QIODevice

496

return new QNonContiguousByteDeviceIoDeviceImpl(device); // FIXME

}

/*!

Create a QNonContiguousByteDevice out of a QIODevice, return it in a QSharedPointer.

501

For QFile, QBuffer and all other QIODevice, sequential or not.

\internal

QSharedPointer<QNonContiguousByteDevice> QNonContiguousByteDeviceFactory::createShared(QIODevice *device)

506

{

507

// shortcut if it is a QBuffer

508

if (QBuffer *buffer = qobject_cast<QBuffer*>(device))

509

return QSharedPointer<QNonContiguousByteDeviceBufferImpl>::create(buffer);

510

511

// ### FIXME special case if device is a QFile that supports map()

512

// then we can actually deal with the file without using read/peek

513

514

// generic QIODevice

515

return QSharedPointer<QNonContiguousByteDeviceIoDeviceImpl>::create(device); // FIXME

}

/*!

\fn static QNonContiguousByteDevice* QNonContiguousByteDeviceFactory::create(QSharedPointer<QRingBuffer> ringBuffer)

520

521

Create a QNonContiguousByteDevice out of a QRingBuffer.

\internal

QNonContiguousByteDevice* QNonContiguousByteDeviceFactory::create(QSharedPointer<QRingBuffer> ringBuffer)

526

{

527

return new QNonContiguousByteDeviceRingBufferImpl(ringBuffer);

}

/*!

Create a QNonContiguousByteDevice out of a QRingBuffer, return it in a QSharedPointer.

\internal

QSharedPointer<QNonContiguousByteDevice> QNonContiguousByteDeviceFactory::createShared(QSharedPointer<QRingBuffer> ringBuffer)

536

{

537

return QSharedPointer<QNonContiguousByteDeviceRingBufferImpl>::create(qMove(ringBuffer));

}

/*!

\fn static QNonContiguousByteDevice* QNonContiguousByteDeviceFactory::create(QByteArray *byteArray)

542

543

Create a QNonContiguousByteDevice out of a QByteArray.

\internal

QNonContiguousByteDevice* QNonContiguousByteDeviceFactory::create(QByteArray *byteArray)

548

{

549

return new QNonContiguousByteDeviceByteArrayImpl(byteArray);

}

/*!

Create a QNonContiguousByteDevice out of a QByteArray.

\internal

QSharedPointer<QNonContiguousByteDevice> QNonContiguousByteDeviceFactory::createShared(QByteArray *byteArray)

558

{

559

return QSharedPointer<QNonContiguousByteDeviceByteArrayImpl>::create(byteArray);

}

/*!

\fn static QIODevice* QNonContiguousByteDeviceFactory::wrap(QNonContiguousByteDevice* byteDevice)

564

565

Wrap the \a byteDevice (possibly again) into a QIODevice.

\internal

QIODevice* QNonContiguousByteDeviceFactory::wrap(QNonContiguousByteDevice* byteDevice)

570

{

571

// ### FIXME if it already has been based on QIoDevice, we could that one out again

572

// and save some calling

573

574

// needed for FTP backend

575

576

return new QByteDeviceWrappingIoDevice(byteDevice);

}

QT_END_NAMESPACE

Generated by Squish Coco Non-Commercial 4.3.0-BETA-master-30-08-2018-4cb69e9