qnoncontiguousbytedevice.cpp

Jenkins

Absolute File Name:

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

Line

Source

Count

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

{

}

QNonContiguousByteDevice::~QNonContiguousByteDevice()

{

}

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

{

buffer = b;

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

arrayImpl = new QNonContiguousByteDeviceByteArrayImpl(&byteArray);

arrayImpl->setParent(this);

connect(arrayImpl, qFlagLocation("2""readyRead()" "\0" __FILE__ ":" "139""145"), qFlagLocation("2""readyRead()" "\0" __FILE__ ":" "139""145"));

connect(arrayImpl, qFlagLocation("2""readProgress(qint64,qint64)" "\0" __FILE__ ":" "140""146"), qFlagLocation("2""readProgress(qint64,qint64)" "\0" __FILE__ ":" "140""146"));

}

QNonContiguousByteDeviceBufferImpl::~QNonContiguousByteDeviceBufferImpl()

{

}

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

{

return arrayImpl->readPointer(maximumLength, len);

}

bool QNonContiguousByteDeviceBufferImpl::advanceReadPointer(qint64 amount)

{

return arrayImpl->advanceReadPointer(amount);

}

bool QNonContiguousByteDeviceBufferImpl::atEnd() const

{

return

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

Executed by:

tst_QNetworkReply
tst_QXmlInputSource
tst_Spdy

arrayImpl->atEnd();

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

Executed by:

tst_QNetworkReply
tst_QXmlInputSource
tst_Spdy

1051

}

bool QNonContiguousByteDeviceBufferImpl::reset()

{

return arrayImpl->reset();

}

qint64 QNonContiguousByteDeviceBufferImpl::size() const

{

return

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

Executed by:

tst_QNetworkReply
tst_QXmlInputSource
tst_Spdy

arrayImpl->size();

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

Executed by:

tst_QNetworkReply
tst_QXmlInputSource
tst_Spdy

1100

}

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)

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

else

len = size() - currentPosition;

return byteArray->constData() + currentPosition;

}

bool QNonContiguousByteDeviceByteArrayImpl::advanceReadPointer(qint64 amount)

{

currentPosition += amount;

readProgress(currentPosition, size());

return true;

}

bool QNonContiguousByteDeviceByteArrayImpl::atEnd() const

{

return

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

Executed by:

tst_QHttpNetworkConnection
tst_QNetworkReply
tst_QXmlInputSource
tst_Spdy

currentPosition >= size();

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

Executed by:

tst_QHttpNetworkConnection
tst_QNetworkReply
tst_QXmlInputSource
tst_Spdy

2361

}

bool QNonContiguousByteDeviceByteArrayImpl::reset()

{

currentPosition = 0;

return true;

}

qint64 QNonContiguousByteDeviceByteArrayImpl::size() const

{

return

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

Executed by:

tst_QHttpNetworkConnection
tst_QNetworkReply
tst_QXmlInputSource
tst_Spdy

byteArray->size();

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

Executed by:

tst_QHttpNetworkConnection
tst_QNetworkReply
tst_QXmlInputSource
tst_Spdy

6023

}

qint64 QNonContiguousByteDeviceByteArrayImpl::pos() const

{

100

return

executed 4 times by 1 test: return currentPosition;

Executed by:

tst_QHttpNetworkConnection

currentPosition;

executed 4 times by 1 test: return currentPosition;

Executed by:

tst_QHttpNetworkConnection

101

}

102

103

QNonContiguousByteDeviceRingBufferImpl::QNonContiguousByteDeviceRingBufferImpl(QSharedPointer<QRingBuffer> rb)

104

: 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);

121

122

if (maximumLength != -1)

123

len = qMin(len, maximumLength);

return returnValue;

}

bool QNonContiguousByteDeviceRingBufferImpl::advanceReadPointer(qint64 amount)

129

{

130

currentPosition += amount;

131

readProgress(currentPosition, size());

return true;

}

bool QNonContiguousByteDeviceRingBufferImpl::atEnd() const

136

{

137

return

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

Executed by:

tst_QNetworkReply

currentPosition >= size();

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

Executed by:

tst_QNetworkReply

1126

138

}

139

140

qint64 QNonContiguousByteDeviceRingBufferImpl::pos() const

141

{

142

return

executed 716 times by 1 test: return currentPosition;

Executed by:

tst_QNetworkReply

currentPosition;

executed 716 times by 1 test: return currentPosition;

Executed by:

tst_QNetworkReply

716

143

}

144

145

bool QNonContiguousByteDeviceRingBufferImpl::reset()

{

currentPosition = 0;

return true;

}

qint64 QNonContiguousByteDeviceRingBufferImpl::size() const

152

{

153

return

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

Executed by:

tst_QNetworkReply

ringBuffer->size();

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

Executed by:

tst_QNetworkReply

2293

154

}

155

156

QNonContiguousByteDeviceIoDeviceImpl::QNonContiguousByteDeviceIoDeviceImpl(QIODevice *d)

157

: QNonContiguousByteDevice(),

158

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

159

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

eof(false)

{

device = d;

initialPosition = d->pos();

164

connect(device, qFlagLocation("2""readyRead()" "\0" __FILE__ ":" "285""291"), this, qFlagLocation("2""readyRead()" "\0" __FILE__ ":" "285""291"), Qt::QueuedConnection);

165

connect(device, qFlagLocation("2""readChannelFinished()" "\0" __FILE__ ":" "286""292"), this, qFlagLocation("2""readyRead()" "\0" __FILE__ ":" "286""292"), Qt::QueuedConnection);

166

}

167

168

QNonContiguousByteDeviceIoDeviceImpl::~QNonContiguousByteDeviceIoDeviceImpl()

169

{

170

delete currentReadBuffer;

171

}

172

173

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

{

if (eof == true) {

len = -1;

return 0;

}

if (currentReadBuffer == 0)

181

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

182

183

if (maximumLength == -1)

184

maximumLength = currentReadBufferSize;

185

186

if (currentReadBufferAmount - currentReadBufferPosition > 0) {

187

len = currentReadBufferAmount - currentReadBufferPosition;

188

return currentReadBuffer->data() + currentReadBufferPosition;

189

}

190

191

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

192

193

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

eof = true;

len = -1;

if (size() == -1)

readProgress(totalAdvancements, totalAdvancements);

return 0;

}

currentReadBufferAmount = haveRead;

203

currentReadBufferPosition = 0;

204

205

len = haveRead;

206

return currentReadBuffer->data();

207

}

208

209

bool QNonContiguousByteDeviceIoDeviceImpl::advanceReadPointer(qint64 amount)

210

{

211

totalAdvancements += amount;

212

213

214

currentReadBufferPosition += amount;

215

216

if (size() == -1)

217

readProgress(totalAdvancements, totalAdvancements);

218

else

219

readProgress(totalAdvancements, size());

220

221

222

if (currentReadBufferPosition > currentReadBufferAmount) {

223

qint64 i = currentReadBufferPosition - currentReadBufferAmount;

224

while (i > 0) {

225

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

226

readProgress(totalAdvancements - i, size());

return false;

}

i--;

}

currentReadBufferPosition = 0;

233

currentReadBufferAmount = 0;

}

return true;

}

bool QNonContiguousByteDeviceIoDeviceImpl::atEnd() const

241

{

242

return

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

Executed by:

tst_QNetworkReply
tst_Spdy

eof == true;

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

Executed by:

tst_QNetworkReply
tst_Spdy

1580

243

}

244

245

bool QNonContiguousByteDeviceIoDeviceImpl::reset()

246

{

247

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

248

if (reset) {

249

eof = false;

250

totalAdvancements = 0;

251

if (currentReadBuffer) {

252

delete currentReadBuffer;

253

currentReadBuffer = 0;

254

}

255

currentReadBufferAmount = 0;

256

currentReadBufferPosition = 0;

return true;

}

return false;

}

qint64 QNonContiguousByteDeviceIoDeviceImpl::size() const

{

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

268

return

executed 607 times by 1 test: return -1;

Executed by:

tst_QNetworkReply

-1;

executed 607 times by 1 test: return -1;

Executed by:

tst_QNetworkReply

607

269

270

return

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

Executed by:

tst_QNetworkReply
tst_Spdy

device->size() - initialPosition;

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

Executed by:

tst_QNetworkReply
tst_Spdy

4707

271

}

272

273

qint64 QNonContiguousByteDeviceIoDeviceImpl::pos() const

274

{

275

if (device->isSequential()

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

)

276

return

never executed: return -1;

-1;

never executed: return -1;

277

278

return

never executed: return device->pos();

device->pos();

never executed: return device->pos();

279

}

280

281

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

282

{

283

byteDevice = bd;

284

connect(bd, qFlagLocation("2""readyRead()" "\0" __FILE__ ":" "405""411"), qFlagLocation("2""readyRead()" "\0" __FILE__ ":" "405""411"));

open(ReadOnly);

}

QByteDeviceWrappingIoDevice::~QByteDeviceWrappingIoDevice()

{

}

bool QByteDeviceWrappingIoDevice::isSequential() const

295

{

296

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

297

}

298

299

bool QByteDeviceWrappingIoDevice::atEnd() const

300

{

301

return byteDevice->atEnd();

302

}

303

304

bool QByteDeviceWrappingIoDevice::reset()

305

{

306

return byteDevice->reset();

307

}

308

309

qint64 QByteDeviceWrappingIoDevice::size() const

{

if (isSequential())

return 0;

return byteDevice->size();

}

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

319

{

320

qint64 len;

321

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

if (len == -1)

return -1;

memcpy(data, readPointer, len);

326

byteDevice->advanceReadPointer(len);

return len;

}

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

{

(void)data;;

(void)maxSize;;

return -1;

}

QNonContiguousByteDevice* QNonContiguousByteDeviceFactory::create(QIODevice *device)

337

{

338

339

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

340

return new QNonContiguousByteDeviceBufferImpl(buffer);

}

return new QNonContiguousByteDeviceIoDeviceImpl(device);

}

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

357

{

358

359

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

360

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

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

367

}

368

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

369

{

370

return new QNonContiguousByteDeviceRingBufferImpl(ringBuffer);

}

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

379

{

380

return QSharedPointer<QNonContiguousByteDeviceRingBufferImpl>::create(std::move(ringBuffer));

381

}

382

QNonContiguousByteDevice* QNonContiguousByteDeviceFactory::create(QByteArray *byteArray)

383

{

384

return new QNonContiguousByteDeviceByteArrayImpl(byteArray);

}

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

393

{

394

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

395

}

396

QIODevice* QNonContiguousByteDeviceFactory::wrap(QNonContiguousByteDevice* byteDevice)

{

return new QByteDeviceWrappingIoDevice(byteDevice);

404

}

405

406

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