FCL/sf/mw/qt: comparison src/corelib/io/qfile.cpp

equal deleted inserted replaced

-:41300fa6a67c
+:f7bc934e204c
 /****************************************************************************
 **
-** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
 **
 ** This file is part of the QtCore module of the Qt Toolkit.
 **
 static const int QFILE_WRITEBUFFER_SIZE = 16384;
 static QByteArray locale_encode(const QString &f)
 {
-#ifndef Q_OS_DARWIN
+#if defined(Q_OS_DARWIN)
-return f.toLocal8Bit();
-#else
 // Mac always expects UTF-8... and decomposed...
 return f.normalized(QString::NormalizationForm_D).toUtf8();
+#elif defined(Q_OS_SYMBIAN)
+return f.toUtf8();
+#else
+return f.toLocal8Bit();
 #endif
 }
 static QString locale_decode(const QByteArray &f)
 {
-#ifndef Q_OS_DARWIN
+#if defined(Q_OS_DARWIN)
-return QString::fromLocal8Bit(f);
-#else
 // Mac always gives us UTF-8 and decomposed, we want that composed...
 return QString::fromUtf8(f).normalized(QString::NormalizationForm_C);
+#elif defined(Q_OS_SYMBIAN)
+return QString::fromUtf8(f);
+#else
+return QString::fromLocal8Bit(f);
 #endif
 }
 //************* QFilePrivate
 QFile::EncoderFn QFilePrivate::encoder = locale_encode;
 QFile::DecoderFn QFilePrivate::decoder = locale_decode;
 QFilePrivate::QFilePrivate()
 : fileEngine(0), lastWasWrite(false),
-writeBuffer(QFILE_WRITEBUFFER_SIZE), error(QFile::NoError)
+writeBuffer(QFILE_WRITEBUFFER_SIZE), error(QFile::NoError),
+cachedSize(0)
 {
 }
 QFilePrivate::~QFilePrivate()
 {
 Q_D(QFile);
 if (d->fileName.isEmpty()) {
 qWarning("QFile::remove: Empty or null file name");
 return false;
 }
+unsetError();
 close();
 if(error() == QFile::NoError) {
 if(fileEngine()->remove()) {
 unsetError();
 return true;
 }
-d->setError(QFile::RemoveError, fileEngine()->errorString());
+d->setError(QFile::RemoveError, d->fileEngine->errorString());
 }
 return false;
 }
 /*!
 close();
 if(error() == QFile::NoError) {
 if (fileEngine()->rename(newName)) {
 unsetError();
 // engine was able to handle the new name so we just reset it
-fileEngine()->setFileName(newName);
+d->fileEngine->setFileName(newName);
 d->fileName = newName;
 return true;
 }
 if (isSequential()) {
 }
 }
 if (error) {
 out.remove();
 } else {
-fileEngine()->setFileName(newName);
+d->fileEngine->setFileName(newName);
 setPermissions(permissions());
 unsetError();
 setFileName(newName);
 }
 close();
 QFileInfo fi(linkName);
 if(fileEngine()->link(fi.absoluteFilePath())) {
 unsetError();
 return true;
 }
-d->setError(QFile::RenameError, fileEngine()->errorString());
+d->setError(QFile::RenameError, d->fileEngine->errorString());
 return false;
 }
 /*!
 \overload
 \note In \l{QIODevice::}{WriteOnly} or \l{QIODevice::}{ReadWrite}
 mode, if the relevant file does not already exist, this function
 will try to create a new file before opening it.
-\note Because of limitations in the native API, QFile ignores the
-Unbuffered flag on Windows.
 \sa QIODevice::OpenMode, setFileName()
 */
 bool QFile::open(OpenMode mode)
 {
 Q_D(QFile);
 unsetError();
 if ((mode & (ReadOnly | WriteOnly)) == 0) {
 qWarning("QIODevice::open: File access not specified");
 return false;
 }
-if (fileEngine()->open(mode)) {
+// QIODevice provides the buffering, so there's no need to request it from the file engine.
+if (fileEngine()->open(mode | QIODevice::Unbuffered)) {
 QIODevice::open(mode);
 if (mode & Append)
 seek(size());
 return true;
 }
-QFile::FileError err = fileEngine()->error();
+QFile::FileError err = d->fileEngine->error();
 if(err == QFile::UnspecifiedError)
 err = QFile::OpenError;
-d->setError(err, fileEngine()->errorString());
+d->setError(err, d->fileEngine->errorString());
 return false;
 }
 /*! \fn QFile::open(OpenMode, FILE*)
 */
 int
 QFile::handle() const
 {
-if (!isOpen())
+Q_D(const QFile);
+if (!isOpen() || !d->fileEngine)
 return -1;
-if (QAbstractFileEngine *engine = fileEngine())
+return d->fileEngine->handle();
-return engine->handle();
-return -1;
 }
 /*!
 \enum QFile::MemoryMapFlags
 \since 4.4
 \sa unmap(), QAbstractFileEngine::supportsExtension()
 */
 uchar *QFile::map(qint64 offset, qint64 size, MemoryMapFlags flags)
 {
 Q_D(QFile);
-QAbstractFileEngine *engine = fileEngine();
+if (fileEngine()
-if (engine
+&& d->fileEngine->supportsExtension(QAbstractFileEngine::MapExtension)) {
-&& engine->supportsExtension(QAbstractFileEngine::MapExtension)) {
 unsetError();
-uchar *address = engine->map(offset, size, flags);
+uchar *address = d->fileEngine->map(offset, size, flags);
 if (address == 0)
-d->setError(engine->error(), engine->errorString());
+d->setError(d->fileEngine->error(), d->fileEngine->errorString());
 return address;
 }
 return 0;
 }
 \sa map(), QAbstractFileEngine::supportsExtension()
 */
 bool QFile::unmap(uchar *address)
 {
 Q_D(QFile);
-QAbstractFileEngine *engine = fileEngine();
+if (fileEngine()
-if (engine
+&& d->fileEngine->supportsExtension(QAbstractFileEngine::UnMapExtension)) {
-&& engine->supportsExtension(QAbstractFileEngine::UnMapExtension)) {
 unsetError();
-bool success = engine->unmap(address);
+bool success = d->fileEngine->unmap(address);
 if (!success)
-d->setError(engine->error(), engine->errorString());
+d->setError(d->fileEngine->error(), d->fileEngine->errorString());
 return success;
 }
 return false;
 }
 QFile::resize(qint64 sz)
 {
 Q_D(QFile);
 if (!d->ensureFlushed())
 return false;
-if (isOpen() && fileEngine()->pos() > sz)
+fileEngine();
+if (isOpen() && d->fileEngine->pos() > sz)
 seek(sz);
-if(fileEngine()->setSize(sz)) {
+if(d->fileEngine->setSize(sz)) {
 unsetError();
+d->cachedSize = sz;
 return true;
 }
-d->setError(QFile::ResizeError, fileEngine()->errorString());
+d->cachedSize = 0;
+d->setError(QFile::ResizeError, d->fileEngine->errorString());
 return false;
 }
 /*!
 \overload
 Q_D(QFile);
 if(fileEngine()->setPermissions(permissions)) {
 unsetError();
 return true;
 }
-d->setError(QFile::PermissionsError, fileEngine()->errorString());
+d->setError(QFile::PermissionsError, d->fileEngine->errorString());
 return false;
 }
 /*!
 \overload
 bool
 QFile::flush()
 {
 Q_D(QFile);
+if (!d->fileEngine) {
+qWarning("QFile::flush: No file engine. Is IODevice open?");
+return false;
+}
 if (!d->writeBuffer.isEmpty()) {
 qint64 size = d->writeBuffer.size();
-if (_qfile_writeData(d->fileEngine ? d->fileEngine : fileEngine(),
+if (_qfile_writeData(d->fileEngine, &d->writeBuffer) != size) {
-&d->writeBuffer) != size) {
+QFile::FileError err = d->fileEngine->error();
-QFile::FileError err = fileEngine()->error();
 if(err == QFile::UnspecifiedError)
 err = QFile::WriteError;
-d->setError(err, fileEngine()->errorString());
+d->setError(err, d->fileEngine->errorString());
 return false;
 }
 }
-if (!fileEngine()->flush()) {
+if (!d->fileEngine->flush()) {
-QFile::FileError err = fileEngine()->error();
+QFile::FileError err = d->fileEngine->error();
 if(err == QFile::UnspecifiedError)
 err = QFile::WriteError;
-d->setError(err, fileEngine()->errorString());
+d->setError(err, d->fileEngine->errorString());
 return false;
 }
 return true;
 }
 QFile::close()
 {
 Q_D(QFile);
 if(!isOpen())
 return;
-flush();
+bool flushed = flush();
 QIODevice::close();
-unsetError();
+// reset write buffer
-if(!fileEngine()->close())
+d->lastWasWrite = false;
-d->setError(fileEngine()->error(), fileEngine()->errorString());
+d->writeBuffer.clear();
+// keep earlier error from flush
+if (d->fileEngine->close() && flushed)
+unsetError();
+else if (flushed)
+d->setError(d->fileEngine->error(), d->fileEngine->errorString());
 }
 /*!
 Returns the size of the file.
 qint64 QFile::size() const
 {
 Q_D(const QFile);
 if (!d->ensureFlushed())
 return 0;
-return fileEngine()->size();
+d->cachedSize = fileEngine()->size();
+return d->cachedSize;
 }
 /*!
 \reimp
 */
 bool QFile::atEnd() const
 {
 Q_D(const QFile);
+// If there's buffered data left, we're not at the end.
+if (!d->buffer.isEmpty())
+return false;
 if (!isOpen())
 return true;
 if (!d->ensureFlushed())
 return false;
-// If there's buffered data left, we're not at the end.
-if (!d->buffer.isEmpty())
-return false;
 // If the file engine knows best, say what it says.
-if (fileEngine()->supportsExtension(QAbstractFileEngine::AtEndExtension)) {
+if (d->fileEngine->supportsExtension(QAbstractFileEngine::AtEndExtension)) {
 // Check if the file engine supports AtEndExtension, and if it does,
 // check if the file engine claims to be at the end.
-return fileEngine()->atEnd();
+return d->fileEngine->atEnd();
 }
+// if it looks like we are at the end, or if size is not cached,
+// fall through to bytesAvailable() to make sure.
+if (pos() < d->cachedSize)
+return false;
 // Fall back to checking how much is available (will stat files).
 return bytesAvailable() == 0;
 }
 }
 if (!d->ensureFlushed())
 return false;
-if (!fileEngine()->seek(off) || !QIODevice::seek(off)) {
+if (!d->fileEngine->seek(off) || !QIODevice::seek(off)) {
-QFile::FileError err = fileEngine()->error();
+QFile::FileError err = d->fileEngine->error();
 if(err == QFile::UnspecifiedError)
 err = QFile::PositionError;
-d->setError(err, fileEngine()->errorString());
+d->setError(err, d->fileEngine->errorString());
 return false;
 }
 unsetError();
 return true;
 }
 {
 Q_D(QFile);
 if (!d->ensureFlushed())
 return -1;
-if (fileEngine()->supportsExtension(QAbstractFileEngine::FastReadLineExtension))
+qint64 read;
-return fileEngine()->readLine(data, maxlen);
+if (d->fileEngine->supportsExtension(QAbstractFileEngine::FastReadLineExtension)) {
+read = d->fileEngine->readLine(data, maxlen);
-// Fall back to QIODevice's readLine implementation if the engine
+} else {
-// cannot do it faster.
+// Fall back to QIODevice's readLine implementation if the engine
-return QIODevice::readLineData(data, maxlen);
+// cannot do it faster.
+read = QIODevice::readLineData(data, maxlen);
+}
+if (read < maxlen) {
+// failed to read all requested, may be at the end of file, stop caching size so that it's rechecked
+d->cachedSize = 0;
+}
+return read;
 }
 /*!
 \reimp
 */
 Q_D(QFile);
 unsetError();
 if (!d->ensureFlushed())
 return -1;
-qint64 ret = -1;
+qint64 read = d->fileEngine->read(data, len);
-qint64 read = fileEngine()->read(data, len);
+if(read < 0) {
-if (read != -1)
+QFile::FileError err = d->fileEngine->error();
-ret = read;
-if(ret < 0) {
-QFile::FileError err = fileEngine()->error();
 if(err == QFile::UnspecifiedError)
 err = QFile::ReadError;
-d->setError(err, fileEngine()->errorString());
+d->setError(err, d->fileEngine->errorString());
 }
-return ret;
+if (read < len) {
+// failed to read all requested, may be at the end of file, stop caching size so that it's rechecked
+d->cachedSize = 0;
+}
+return read;
 }
 /*!
 \internal
 */
 }
 // Write directly to the engine if the block size is larger than
 // the write buffer size.
 if (!buffered || len > QFILE_WRITEBUFFER_SIZE) {
-QAbstractFileEngine *fe = d->fileEngine ? d->fileEngine : fileEngine();
+qint64 ret = d->fileEngine->write(data, len);
-qint64 ret = fe->write(data, len);
 if(ret < 0) {
-QFile::FileError err = fileEngine()->error();
+QFile::FileError err = d->fileEngine->error();
 if(err == QFile::UnspecifiedError)
 err = QFile::WriteError;
-d->setError(err, fileEngine()->errorString());
+d->setError(err, d->fileEngine->errorString());
 }
 return ret;
 }
 // Write to the buffer.

changeset 7	f7bc934e204c
parent 3	41300fa6a67c