OSDN Git Service

merge QFSFileEngine into QAbstractFileEngine
authorIvailo Monev <xakepa10@gmail.com>
Sat, 29 Oct 2022 18:20:01 +0000 (21:20 +0300)
committerIvailo Monev <xakepa10@gmail.com>
Sat, 29 Oct 2022 18:42:58 +0000 (21:42 +0300)
that finally happened

Signed-off-by: Ivailo Monev <xakepa10@gmail.com>
24 files changed:
package/freebsd/pkg-plist
scripts/namefsck.py
src/core/CMakeLists.txt
src/core/io/qabstractfileengine.cpp
src/core/io/qabstractfileengine.h
src/core/io/qabstractfileengine_p.h
src/core/io/qdir.cpp
src/core/io/qdiriterator.cpp
src/core/io/qfile.cpp
src/core/io/qfileinfo.h
src/core/io/qfilesystemengine_unix.cpp
src/core/io/qfilesystementry.cpp
src/core/io/qfsfileengine.cpp [deleted file]
src/core/io/qfsfileengine.h [deleted file]
src/core/io/qfsfileengine_iterator.cpp [deleted file]
src/core/io/qfsfileengine_iterator_p.h [deleted file]
src/core/io/qfsfileengine_p.h [deleted file]
src/core/io/qfsfileengine_unix.cpp [deleted file]
src/core/io/qtemporaryfile.cpp
src/gui/dialogs/qfileinfogatherer.cpp
src/tools/moc/CMakeLists.txt
src/tools/uic/cpp/cppwriteincludes.cpp
tests/auto/qfile/tst_qfile.cpp
tests/benchmarks/core/io/qfile/main.cpp

index 46d4003..63113a3 100644 (file)
@@ -44,7 +44,6 @@ include/katie/QtCore/QElapsedTimer
 include/katie/QtCore/QEvent
 include/katie/QtCore/QEventLoop
 include/katie/QtCore/QExplicitlySharedDataPointer
-include/katie/QtCore/QFSFileEngine
 include/katie/QtCore/QFile
 include/katie/QtCore/QFileInfo
 include/katie/QtCore/QFileInfoList
@@ -211,7 +210,6 @@ include/katie/QtCore/qeventloop.h
 include/katie/QtCore/qfile.h
 include/katie/QtCore/qfileinfo.h
 include/katie/QtCore/qfilesystemwatcher.h
-include/katie/QtCore/qfsfileengine.h
 include/katie/QtCore/qglobal.h
 include/katie/QtCore/qhash.h
 include/katie/QtCore/qiodevice.h
index 355cf12..479506c 100755 (executable)
@@ -207,7 +207,6 @@ classlist = [
     "QFontMetricsF",
     "QFormLayout",
     "QFrame",
-    "QFSFileEngine",
     "QFtp",
     "QFuture",
     "QFutureInterface",
index 343a707..f489dd0 100644 (file)
@@ -35,7 +35,6 @@ set(CORE_PUBLIC_HEADERS
     QStandardPaths
     QPlugin
     QPluginLoader
-    QFSFileEngine
     QLine
     QIODevice
     QPair
@@ -129,9 +128,6 @@ set(CORE_HEADERS
     ${CMAKE_CURRENT_SOURCE_DIR}/io/qsettings.h
     ${CMAKE_CURRENT_SOURCE_DIR}/io/qsettings_p.h
     ${CMAKE_CURRENT_SOURCE_DIR}/io/qstandardpaths.h
-    ${CMAKE_CURRENT_SOURCE_DIR}/io/qfsfileengine.h
-    ${CMAKE_CURRENT_SOURCE_DIR}/io/qfsfileengine_p.h
-    ${CMAKE_CURRENT_SOURCE_DIR}/io/qfsfileengine_iterator_p.h
     ${CMAKE_CURRENT_SOURCE_DIR}/io/qfilesystemwatcher.h
     ${CMAKE_CURRENT_SOURCE_DIR}/io/qfilesystemwatcher_p.h
     ${CMAKE_CURRENT_SOURCE_DIR}/io/qfilesystemwatcher_unix_p.h
@@ -252,12 +248,9 @@ set(CORE_SOURCES
     ${CMAKE_CURRENT_SOURCE_DIR}/io/qurl.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/io/qsettings.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/io/qstandardpaths.cpp
-    ${CMAKE_CURRENT_SOURCE_DIR}/io/qfsfileengine.cpp
-    ${CMAKE_CURRENT_SOURCE_DIR}/io/qfsfileengine_iterator.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/io/qfilesystemwatcher.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/io/qfilesystemwatcher_unix.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/io/qfilesystementry.cpp
-    ${CMAKE_CURRENT_SOURCE_DIR}/io/qfsfileengine_unix.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/io/qfilesystemengine_unix.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/io/qprocess_unix.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/io/qfilesystemiterator_unix.cpp
index 3155992..d7561e9 100644 (file)
 #include "qabstractfileengine_p.h"
 #include "qdatetime.h"
 #include "qvariant.h"
+#include "qdebug.h"
 #include "qfilesystementry_p.h"
 #include "qfilesystemengine_p.h"
+#include "qfileinfo_p.h"
+#include "qcore_unix_p.h"
 // built-in handlers
-#include "qfsfileengine.h"
 #include "qdiriterator.h"
 
+#include <sys/mman.h>
+#include <stdlib.h>
+#include <limits.h>
+#include <errno.h>
+
 QT_BEGIN_NAMESPACE
 
 /*!
+    \internal
+*/
+void QAbstractFileEnginePrivate::init()
+{
+    metaData.clear();
+    openMode = QIODevice::NotOpen;
+    fd = -1;
+    closeFileHandle = false;
+}
+
+bool QAbstractFileEnginePrivate::doStat(QFileSystemMetaData::MetaDataFlags flags) const
+{
+    if (!metaData.hasFlags(flags)) {
+        if (!fileEntry.isEmpty())
+            QFileSystemEngine::fillMetaData(fileEntry, metaData, metaData.missingFlags(flags));
+
+        if (metaData.missingFlags(flags) && fd != -1)
+            QFileSystemEngine::fillMetaData(fd, metaData);
+    }
+
+    return metaData.exists();
+}
+
+uchar *QAbstractFileEnginePrivate::map(qint64 offset, qint64 size)
+{
+    Q_Q(QAbstractFileEngine);
+    if (openMode == QIODevice::NotOpen) {
+        q->setError(QFile::PermissionsError, qt_error_string(EACCES));
+        return 0;
+    }
+
+    if (offset < 0 || offset != qint64(QT_OFF_T(offset))
+            || size < 0 || quint64(size) > quint64(size_t(-1))) {
+        q->setError(QFile::UnspecifiedError, qt_error_string(EINVAL));
+        return 0;
+    }
+
+    // If we know the mapping will extend beyond EOF, fail early to avoid
+    // undefined behavior. Otherwise, let mmap have its say.
+    if (doStat(QFileSystemMetaData::SizeAttribute)
+            && (QT_OFF_T(size) > metaData.size() - QT_OFF_T(offset)))
+        qWarning("QAbstractFileEngine::map: Mapping a file beyond its size is not portable");
+
+    int access = 0;
+    if (openMode & QIODevice::ReadOnly) access |= PROT_READ;
+    if (openMode & QIODevice::WriteOnly) access |= PROT_WRITE;
+
+    static const int pageSize = ::getpagesize();
+    const int extra = offset % pageSize;
+
+    if (quint64(size + extra) > quint64((size_t)-1)) {
+        q->setError(QFile::UnspecifiedError, qt_error_string(EINVAL));
+        return 0;
+    }
+
+    size_t realSize = (size_t)size + extra;
+    QT_OFF_T realOffset = QT_OFF_T(offset);
+    realOffset &= ~(QT_OFF_T(pageSize - 1));
+
+    void *mapAddress = QT_MMAP(nullptr, realSize,
+                   access, MAP_SHARED, fd, realOffset);
+    if (mapAddress != MAP_FAILED) {
+        uchar *address = extra + static_cast<uchar*>(mapAddress);
+        maps[address] = QPair<int,size_t>(extra, realSize);
+        return address;
+    }
+
+    switch(errno) {
+    case EBADF:
+        q->setError(QFile::PermissionsError, qt_error_string(EACCES));
+        break;
+    case ENFILE:
+    case ENOMEM:
+        q->setError(QFile::ResourceError, qt_error_string(errno));
+        break;
+    case EINVAL:
+        // size are out of bounds
+    default:
+        q->setError(QFile::UnspecifiedError, qt_error_string(errno));
+        break;
+    }
+    return 0;
+}
+
+bool QAbstractFileEnginePrivate::unmap(uchar *ptr)
+{
+    Q_Q(QAbstractFileEngine);
+    if (!maps.contains(ptr)) {
+        q->setError(QFile::PermissionsError, qt_error_string(EACCES));
+        return false;
+    }
+
+    uchar *start = ptr - maps[ptr].first;
+    size_t len = maps[ptr].second;
+    if (::munmap(start, len) == -1) {
+        q->setError(QFile::UnspecifiedError, qt_error_string(errno));
+        return false;
+    }
+    maps.remove(ptr);
+    return true;
+}
+
+/*!
     Creates and returns a QAbstractFileEngine suitable for processing \a
     fileName.
 
@@ -46,7 +156,9 @@ QAbstractFileEngine *QAbstractFileEngine::create(const QString &fileName)
 {
 #ifndef QT_NO_FSFILEENGINE
     // fall back to regular file engine
-    return new QFSFileEngine(fileName);
+    QAbstractFileEngine *engine = new QAbstractFileEngine();
+    engine->d_ptr->fileEntry = QFileSystemEntry(fileName);
+    return engine;
 #else
     return nullptr;
 #endif
@@ -172,6 +284,16 @@ QAbstractFileEngine::QAbstractFileEngine(QAbstractFileEnginePrivate &dd) : d_ptr
  */
 QAbstractFileEngine::~QAbstractFileEngine()
 {
+    Q_D(QAbstractFileEngine);
+    if (d->closeFileHandle) {
+        if (d->fd != -1) {
+            qt_safe_close(d->fd);
+        }
+    }
+    QList<uchar*> keys = d->maps.keys();
+    for (int i = 0; i < keys.count(); ++i)
+        unmap(keys.at(i));
+
     delete d_ptr;
 }
 
@@ -186,8 +308,86 @@ QAbstractFileEngine::~QAbstractFileEngine()
 */
 bool QAbstractFileEngine::open(QIODevice::OpenMode openMode)
 {
-    Q_UNUSED(openMode);
-    return false;
+    Q_D(QAbstractFileEngine);
+    if (Q_UNLIKELY(d->fileEntry.isEmpty())) {
+        qWarning("QAbstractFileEngine::open: No file name specified");
+        setError(QFile::OpenError, QLatin1String("No file name specified"));
+        return false;
+    }
+
+    // Append implies WriteOnly.
+    if (openMode & QFile::Append)
+        openMode |= QFile::WriteOnly;
+
+    // WriteOnly implies Truncate if neither ReadOnly nor Append are sent.
+    if ((openMode & QFile::WriteOnly) && !(openMode & (QFile::ReadOnly | QFile::Append)))
+        openMode |= QFile::Truncate;
+
+    d->openMode = openMode;
+    d->metaData.clear();
+    d->fd = -1;
+
+    int flags = QT_OPEN_RDONLY;
+
+    if ((d->openMode & QFile::ReadWrite) == QFile::ReadWrite) {
+        flags = QT_OPEN_RDWR | QT_OPEN_CREAT;
+    } else if (d->openMode & QFile::WriteOnly) {
+        flags = QT_OPEN_WRONLY | QT_OPEN_CREAT;
+    }
+
+    if (d->openMode & QFile::Append) {
+        flags |= QT_OPEN_APPEND;
+    } else if (d->openMode & QFile::WriteOnly) {
+        if ((d->openMode & QFile::Truncate) || !(d->openMode & QFile::ReadOnly))
+            flags |= QT_OPEN_TRUNC;
+    }
+
+    if (d->openMode & QFile::Unbuffered) {
+#ifdef O_DSYNC
+        flags |= O_DSYNC;
+#else
+        flags |= O_SYNC;
+#endif
+    }
+
+    // Try to open the file.
+    const QByteArray native = d->fileEntry.nativeFilePath();
+    d->fd = qt_safe_open(native.constData(), flags, 0666);
+
+    // On failure, return and report the error.
+    if (d->fd == -1) {
+        setError(errno == EMFILE ? QFile::ResourceError : QFile::OpenError,
+                 qt_error_string(errno));
+        d->openMode = QIODevice::NotOpen;
+        return false;
+    }
+
+    // Refuse to open directories, EISDIR is not a thing (by standards) for
+    // non-write modes.
+    QT_STATBUF statbuf;
+    if (QT_FSTAT(d->fd, &statbuf) == 0 && S_ISDIR(statbuf.st_mode)) {
+        setError(QFile::OpenError, QLatin1String("file to open is a directory"));
+        qt_safe_close(d->fd);
+        d->openMode = QIODevice::NotOpen;
+        d->fd = -1;
+        return false;
+    }
+
+    // Seek to the end when in Append mode.
+    if (d->openMode & QFile::Append) {
+        if (QT_LSEEK(d->fd, 0, SEEK_END) == -1) {
+            setError(errno == EMFILE ? QFile::ResourceError : QFile::OpenError,
+                     qt_error_string(errno));
+            qt_safe_close(d->fd);
+            d->openMode = QIODevice::NotOpen;
+            d->fd = -1;
+            return false;
+        }
+    }
+
+    d->closeFileHandle = true;
+
+    return true;
 }
 
 /*!
@@ -197,7 +397,30 @@ bool QAbstractFileEngine::open(QIODevice::OpenMode openMode)
 */
 bool QAbstractFileEngine::close()
 {
-    return false;
+    Q_D(QAbstractFileEngine);
+    d->openMode = QIODevice::NotOpen;
+
+    if (d->fd == -1)
+        return false;
+
+    d->metaData.clear();
+
+    // Close the file if we created the handle.
+    if (d->closeFileHandle) {
+        int ret = qt_safe_close(d->fd);
+
+        // We must reset these guys regardless; calling close again after a
+        // failed close causes crashes on some systems.
+        d->fd = -1;
+
+        // Report errors.
+        if (ret != 0) {
+            setError(QFile::UnspecifiedError, qt_error_string(errno));
+            return false;
+        }
+    }
+
+    return true;
 }
 
 /*!
@@ -208,7 +431,8 @@ bool QAbstractFileEngine::close()
 */
 bool QAbstractFileEngine::flush()
 {
-    return false;
+    Q_D(const QAbstractFileEngine);
+    return (d->fd != -1);
 }
 
 /*!
@@ -216,7 +440,11 @@ bool QAbstractFileEngine::flush()
 */
 qint64 QAbstractFileEngine::size() const
 {
-    return 0;
+    Q_D(const QAbstractFileEngine);
+
+    if (!d->doStat(QFileSystemMetaData::SizeAttribute))
+        return 0;
+    return d->metaData.size();
 }
 
 /*!
@@ -226,7 +454,8 @@ qint64 QAbstractFileEngine::size() const
 */
 qint64 QAbstractFileEngine::pos() const
 {
-    return 0;
+    Q_D(const QAbstractFileEngine);
+    return (qint64)QT_LSEEK(d->fd, 0, SEEK_CUR);
 }
 
 /*!
@@ -242,8 +471,17 @@ qint64 QAbstractFileEngine::pos() const
 */
 bool QAbstractFileEngine::seek(qint64 pos)
 {
-    Q_UNUSED(pos);
-    return false;
+    Q_D(QAbstractFileEngine);
+
+    if (pos < 0 || pos != qint64(QT_OFF_T(pos)))
+        return false;
+
+    if (Q_UNLIKELY(QT_LSEEK(d->fd, QT_OFF_T(pos), SEEK_SET) == -1)) {
+        qWarning("QAbstractFileEngine::seek: Cannot set file position %lld", pos);
+        setError(QFile::PositionError, qt_error_string(errno));
+        return false;
+    }
+    return true;
 }
 
 /*!
@@ -255,7 +493,10 @@ bool QAbstractFileEngine::seek(qint64 pos)
 */
 bool QAbstractFileEngine::isSequential() const
 {
-    return false;
+    Q_D(const QAbstractFileEngine);
+    if (d->doStat(QFileSystemMetaData::SequentialType))
+        return d->metaData.isSequential();
+    return true;
 }
 
 /*!
@@ -268,7 +509,14 @@ bool QAbstractFileEngine::isSequential() const
  */
 bool QAbstractFileEngine::remove()
 {
-    return false;
+    Q_D(QAbstractFileEngine);
+    int error;
+    bool ret = QFileSystemEngine::removeFile(d->fileEntry, &error);
+    d->metaData.clear();
+    if (!ret) {
+        setError(QFile::RemoveError, qt_error_string(error));
+    }
+    return ret;
 }
 
 /*!
@@ -277,8 +525,13 @@ bool QAbstractFileEngine::remove()
 */
 bool QAbstractFileEngine::copy(const QString &newName)
 {
-    Q_UNUSED(newName);
-    return false;
+    Q_D(QAbstractFileEngine);
+    int error;
+    bool ret = QFileSystemEngine::copyFile(d->fileEntry, QFileSystemEntry(newName), &error);
+    if (!ret) {
+        setError(QFile::CopyError, qt_error_string(error));
+    }
+    return ret;
 }
 
 /*!
@@ -292,8 +545,15 @@ bool QAbstractFileEngine::copy(const QString &newName)
  */
 bool QAbstractFileEngine::rename(const QString &newName)
 {
-    Q_UNUSED(newName);
-    return false;
+    Q_D(QAbstractFileEngine);
+    int error;
+    bool ret = QFileSystemEngine::renameFile(d->fileEntry, QFileSystemEntry(newName), &error);
+    d->metaData.clear();
+    if (!ret) {
+        setError(QFile::RenameError, qt_error_string(error));
+    }
+
+    return ret;
 }
 
 /*!
@@ -304,8 +564,13 @@ bool QAbstractFileEngine::rename(const QString &newName)
 */
 bool QAbstractFileEngine::link(const QString &newName)
 {
-    Q_UNUSED(newName);
-    return false;
+    Q_D(QAbstractFileEngine);
+    int error;
+    bool ret = QFileSystemEngine::createLink(d->fileEntry, QFileSystemEntry(newName), &error);
+    if (!ret) {
+        setError(QFile::RenameError, qt_error_string(error));
+    }
+    return ret;
 }
 
 /*!
@@ -322,9 +587,7 @@ bool QAbstractFileEngine::link(const QString &newName)
  */
 bool QAbstractFileEngine::mkdir(const QString &dirName, bool createParentDirectories) const
 {
-    Q_UNUSED(dirName);
-    Q_UNUSED(createParentDirectories);
-    return false;
+    return QFileSystemEngine::createDirectory(QFileSystemEntry(dirName), createParentDirectories);
 }
 
 /*!
@@ -342,9 +605,7 @@ bool QAbstractFileEngine::mkdir(const QString &dirName, bool createParentDirecto
  */
 bool QAbstractFileEngine::rmdir(const QString &dirName, bool recurseParentDirectories) const
 {
-    Q_UNUSED(dirName);
-    Q_UNUSED(recurseParentDirectories);
-    return false;
+    return QFileSystemEngine::removeDirectory(QFileSystemEntry(dirName), recurseParentDirectories);
 }
 
 /*!
@@ -359,8 +620,19 @@ bool QAbstractFileEngine::rmdir(const QString &dirName, bool recurseParentDirect
 */
 bool QAbstractFileEngine::setSize(qint64 size)
 {
-    Q_UNUSED(size);
-    return false;
+    Q_D(QAbstractFileEngine);
+    int ret = 0;
+    if (d->fd != -1) {
+        Q_EINTR_LOOP(ret, QT_FTRUNCATE(d->fd, size));
+    } else {
+        Q_EINTR_LOOP(ret, QT_TRUNCATE(d->fileEntry.nativeFilePath().constData(), size));
+    }
+    d->metaData.clearFlags(QFileSystemMetaData::SizeAttribute);
+    if (ret == -1) {
+        setError(QFile::ResizeError, qt_error_string(errno));
+        return false;
+    }
+    return true;
 }
 
 /*!
@@ -373,7 +645,8 @@ bool QAbstractFileEngine::setSize(qint64 size)
  */
 bool QAbstractFileEngine::isRelativePath() const
 {
-    return false;
+    Q_D(const QAbstractFileEngine);
+    return d->fileEntry.filePath().length() ? d->fileEntry.filePath()[0] != QLatin1Char('/') : true;
 }
 
 /*!
@@ -417,8 +690,60 @@ QStringList QAbstractFileEngine::entryList(QDir::Filters filters, const QStringL
 */
 QAbstractFileEngine::FileFlags QAbstractFileEngine::fileFlags(FileFlags type) const
 {
-    Q_UNUSED(type);
-    return 0;
+    Q_D(const QAbstractFileEngine);
+
+    if (type & Refresh)
+        d->metaData.clear();
+
+    QAbstractFileEngine::FileFlags ret = 0;
+
+    if (type & FlagsMask)
+        ret |= LocalDiskFlag;
+
+    QFileSystemMetaData::MetaDataFlags queryFlags =
+            QFileSystemMetaData::MetaDataFlags(uint(type))
+            & QFileSystemMetaData::Permissions;
+    queryFlags |= QFileSystemMetaData::LinkType;
+
+    if (type & TypesMask)
+        queryFlags |= QFileSystemMetaData::LinkType
+                | QFileSystemMetaData::FileType
+                | QFileSystemMetaData::DirectoryType;
+
+    if (type & FlagsMask)
+        queryFlags |= QFileSystemMetaData::HiddenAttribute
+                | QFileSystemMetaData::ExistsAttribute;
+
+    bool exists = d->doStat(queryFlags);
+
+    if (!exists && !d->metaData.isLink())
+        return ret;
+
+    if (exists && (type & PermsMask))
+        ret |= FileFlags(uint(d->metaData.permissions()));
+
+    if (type & TypesMask) {
+        if ((type & LinkType) && d->metaData.isLink())
+            ret |= LinkType;
+        if (exists) {
+            if (d->metaData.isFile()) {
+                ret |= FileType;
+            } else if (d->metaData.isDirectory()) {
+                ret |= DirectoryType;
+            }
+        }
+    }
+
+    if (type & FlagsMask) {
+        if (exists)
+            ret |= ExistsFlag;
+        if (d->fileEntry.isRoot())
+            ret |= RootFlag;
+        else if (d->metaData.isHidden())
+            ret |= HiddenFlag;
+    }
+
+    return ret;
 }
 
 /*!
@@ -434,8 +759,13 @@ QAbstractFileEngine::FileFlags QAbstractFileEngine::fileFlags(FileFlags type) co
 */
 bool QAbstractFileEngine::setPermissions(uint perms)
 {
-    Q_UNUSED(perms);
-    return false;
+    Q_D(QAbstractFileEngine);
+    int error;
+    if (!QFileSystemEngine::setPermissions(d->fileEntry, QFile::Permissions(perms), &error)) {
+        setError(QFile::PermissionsError, qt_error_string(error));
+        return false;
+    }
+    return true;
 }
 
 /*!
@@ -452,8 +782,32 @@ bool QAbstractFileEngine::setPermissions(uint perms)
  */
 QString QAbstractFileEngine::fileName(FileName file) const
 {
-    Q_UNUSED(file);
-    return QString();
+    Q_D(const QAbstractFileEngine);
+    if (file == BaseName) {
+        return d->fileEntry.fileName();
+    } else if (file == PathName) {
+        return d->fileEntry.path();
+    } else if (file == AbsoluteName || file == AbsolutePathName) {
+        QFileSystemEntry entry(QFileSystemEngine::absoluteName(d->fileEntry));
+        if (file == AbsolutePathName) {
+            return entry.path();
+        }
+        return entry.filePath();
+    } else if (file == CanonicalName || file == CanonicalPathName) {
+        QFileSystemEntry entry(QFileSystemEngine::canonicalName(d->fileEntry, d->metaData));
+        if (file == CanonicalPathName)
+            return entry.path();
+        return entry.filePath();
+    } else if (file == LinkName) {
+        if (!d->metaData.hasFlags(QFileSystemMetaData::LinkType))
+            QFileSystemEngine::fillMetaData(d->fileEntry, d->metaData, QFileSystemMetaData::LinkType);
+        if (d->metaData.isLink()) {
+            QFileSystemEntry entry = QFileSystemEngine::getLinkTarget(d->fileEntry, d->metaData);
+            return entry.filePath();
+        }
+        return QString();
+    }
+    return d->fileEntry.filePath();
 }
 
 /*!
@@ -467,8 +821,15 @@ QString QAbstractFileEngine::fileName(FileName file) const
  */
 uint QAbstractFileEngine::ownerId(FileOwner owner) const
 {
-    Q_UNUSED(owner);
-    return 0;
+    Q_D(const QAbstractFileEngine);
+
+    if (d->doStat(QFileSystemMetaData::OwnerIds)) {
+        if (owner == QAbstractFileEngine::OwnerUser)
+            return d->metaData.userId();
+        return d->metaData.groupId();
+    }
+
+    return QFileSystemMetaData::nobodyID;
 }
 
 /*!
@@ -483,8 +844,9 @@ uint QAbstractFileEngine::ownerId(FileOwner owner) const
  */
 QString QAbstractFileEngine::owner(FileOwner owner) const
 {
-    Q_UNUSED(owner);
-    return QString();
+    if (owner == QAbstractFileEngine::OwnerUser)
+        return QFileSystemEngine::resolveUserName(ownerId(owner));
+    return QFileSystemEngine::resolveGroupName(ownerId(owner));
 }
 
 /*!
@@ -501,7 +863,19 @@ QString QAbstractFileEngine::owner(FileOwner owner) const
  */
 QDateTime QAbstractFileEngine::fileTime(FileTime time) const
 {
-    Q_UNUSED(time);
+    Q_D(const QAbstractFileEngine);
+
+    if (d->doStat(QFileSystemMetaData::Times)) {
+        switch (time) {
+        case QAbstractFileEngine::ModificationTime:
+            return d->metaData.modificationTime();
+        case QAbstractFileEngine::AccessTime:
+            return d->metaData.accessTime();
+        case QAbstractFileEngine::CreationTime:
+            return d->metaData.creationTime();
+        }
+    }
+
     return QDateTime();
 }
 
@@ -515,7 +889,9 @@ QDateTime QAbstractFileEngine::fileTime(FileTime time) const
  */
 void QAbstractFileEngine::setFileName(const QString &file)
 {
-    Q_UNUSED(file);
+    Q_D(QAbstractFileEngine);
+    d->init();
+    d->fileEntry = QFileSystemEntry(file);
 }
 
 /*!
@@ -525,7 +901,8 @@ void QAbstractFileEngine::setFileName(const QString &file)
 */
 int QAbstractFileEngine::handle() const
 {
-    return -1;
+    Q_D(const QAbstractFileEngine);
+    return d->fd;
 }
 
 /*!
@@ -573,259 +950,102 @@ bool QAbstractFileEngine::unmap(uchar *address)
 }
 
 /*!
-    \since 4.3
-    \class QAbstractFileEngineIterator
-    \brief The QAbstractFileEngineIterator class provides an iterator
-    interface for custom file engines.
-
-    If all you want is to iterate over entries in a directory, see
-    QDirIterator instead. This class is only for custom file engine authors.
-
-    QAbstractFileEngineIterator is a unidirectional single-use virtual
-    iterator that plugs into QDirIterator, providing transparent proxy
-    iteration for custom file engines.
-
-    You can subclass QAbstractFileEngineIterator to provide an iterator when
-    writing your own file engine. To plug the iterator into your file system,
-    you simply return an instance of this subclass from a reimplementation of
-    QAbstractFileEngine::beginEntryList().
-
-    Example:
-
-    \snippet doc/src/snippets/code/src_corelib_io_qabstractfileengine.cpp 2
-
-    QAbstractFileEngineIterator is associated with a path, name filters, and
-    entry filters. The path is the directory that the iterator lists entries
-    in. The name filters and entry filters are provided for file engines that
-    can optimize directory listing at the iterator level (e.g., network file
-    systems that need to minimize network traffic), but they can also be
-    ignored by the iterator subclass; QAbstractFileEngineIterator already
-    provides the required filtering logics in the matchesFilters() function.
-    You can call dirName() to get the directory name, nameFilters() to get a
-    stringlist of name filters, and filters() to get the entry filters.
-
-    The pure virtual function hasNext() returns true if the current directory
-    has at least one more entry (i.e., the directory name is valid and
-    accessible, and we have not reached the end of the entry list), and false
-    otherwise. Reimplement next() to seek to the next entry.
-
-    The pure virtual function currentFileName() returns the name of the
-    current entry without advancing the iterator. The currentFilePath()
-    function is provided for convenience; it returns the full path of the
-    current entry.
-
-    Here is an example of how to implement an iterator that returns each of
-    three fixed entries in sequence.
-
-    \snippet doc/src/snippets/code/src_corelib_io_qabstractfileengine.cpp 3
+    Returns an instance of a QAbstractFileEngineIterator using \a filters for
+    entry filtering and \a filterNames for name filtering. This function is
+    called by QDirIterator to initiate directory iteration.
 
-    Note: QAbstractFileEngineIterator does not deal with QDir::IteratorFlags;
-    it simply returns entries for a single directory.
+    QDirIterator takes ownership of the returned instance, and deletes it when
+    it's done.
 
     \sa QDirIterator
 */
-
-/*!
-    \typedef QAbstractFileEngine::Iterator
-    \since 4.3
-    \relates QAbstractFileEngine
-
-    Synonym for QAbstractFileEngineIterator.
-*/
-
-class QAbstractFileEngineIteratorPrivate
+QAbstractFileEngine::Iterator *QAbstractFileEngine::beginEntryList(QDir::Filters filters, const QStringList &filterNames)
 {
-public:
-    QString path;
-    QDir::Filters filters;
-    QStringList nameFilters;
-    QFileInfo fileInfo;
-};
+#ifndef QT_NO_FILESYSTEMITERATOR
+    return new QAbstractFileEngineIterator(filters, filterNames);
+#else
+    Q_UNUSED(filters);
+    Q_UNUSED(filterNames);
+    return nullptr;
+#endif
+}
 
 /*!
-    Constructs a QAbstractFileEngineIterator, using the entry filters \a
-    filters, and wildcard name filters \a nameFilters.
+    \internal
 */
-QAbstractFileEngineIterator::QAbstractFileEngineIterator(QDir::Filters filters,
-                                                         const QStringList &nameFilters)
-    : d(new QAbstractFileEngineIteratorPrivate)
+QAbstractFileEngine::Iterator *QAbstractFileEngine::endEntryList()
 {
-    d->nameFilters = nameFilters;
-    d->filters = filters;
+    return nullptr;
 }
 
 /*!
-    Destroys the QAbstractFileEngineIterator.
+    Reads a number of characters from the file into \a data. At most
+    \a maxlen characters will be read.
 
-    \sa QDirIterator
+    Returns -1 if a fatal error occurs, or 0 if there are no bytes to
+    read.
 */
-QAbstractFileEngineIterator::~QAbstractFileEngineIterator()
+qint64 QAbstractFileEngine::read(char *data, qint64 maxlen)
 {
-    delete d;
-}
+    Q_D(QAbstractFileEngine);
 
-/*!
-    Returns the path for this iterator. QDirIterator is responsible for
-    assigning this path; it cannot change during the iterator's lifetime.
+    if (maxlen < 0) {
+        setError(QFile::ReadError, qt_error_string(EINVAL));
+        return -1;
+    }
 
-    \sa nameFilters(), filters()
-*/
-QString QAbstractFileEngineIterator::path() const
-{
-    return d->path;
-}
+    qint64 readBytes = 0;
+    bool eof = false;
 
-/*!
-    \internal
+    if (d->fd != -1) {
+        ssize_t result;
+        do {
+            result = QT_READ(d->fd, data + readBytes, size_t(maxlen - readBytes));
+        } while ((result == -1 && errno == EINTR)
+                || (result > 0 && (readBytes += result) < maxlen));
 
-    Sets the iterator path to \a path. This function is called from within
-    QDirIterator.
-*/
-void QAbstractFileEngineIterator::setPath(const QString &path)
-{
-    d->path = path;
-}
+        eof = !(result == -1);
+    }
 
-/*!
-    Returns the name filters for this iterator.
+    if (!eof && readBytes == 0) {
+        readBytes = -1;
+        setError(QFile::ReadError, qt_error_string(errno));
+    }
 
-    \sa QDir::nameFilters(), filters(), path()
-*/
-QStringList QAbstractFileEngineIterator::nameFilters() const
-{
-    return d->nameFilters;
+    return readBytes;
 }
 
 /*!
-    Returns the entry filters for this iterator.
-
-    \sa QDir::filter(), nameFilters(), path()
+    Writes \a len bytes from \a data to the file. Returns the number
+    of characters written on success; otherwise returns -1.
 */
-QDir::Filters QAbstractFileEngineIterator::filters() const
+qint64 QAbstractFileEngine::write(const char *data, qint64 len)
 {
-    return d->filters;
-}
-
-/*!
-    \fn QString QAbstractFileEngineIterator::currentFileName() const = 0
-
-    This pure virtual function returns the name of the current directory
-    entry, excluding the path.
-
-    \sa currentFilePath()
-*/
-
-/*!
-    Returns the path to the current directory entry. It's the same as
-    prepending path() to the return value of currentFileName().
+    Q_D(QAbstractFileEngine);
 
-    \sa currentFileName()
-*/
-QString QAbstractFileEngineIterator::currentFilePath() const
-{
-    QString name = currentFileName();
-    if (!name.isNull()) {
-        QString tmp = path();
-        if (!tmp.isEmpty()) {
-            if (!tmp.endsWith(QLatin1Char('/')))
-                tmp.append(QLatin1Char('/'));
-            name.prepend(tmp);
-        }
+    if (len < 0 || len != qint64(size_t(len))) {
+        setError(QFile::WriteError, qt_error_string(EINVAL));
+        return -1;
     }
-    return name;
-}
 
-/*!
-    The virtual function returns a QFileInfo for the current directory
-    entry. This function is provided for convenience. It can also be slightly
-    faster than creating a QFileInfo object yourself, as the object returned
-    by this function might contain cached information that QFileInfo otherwise
-    would have to access through the file engine.
-
-    \sa currentFileName()
-*/
-QFileInfo QAbstractFileEngineIterator::currentFileInfo() const
-{
-    QString path = currentFilePath();
-    if (d->fileInfo.filePath() != path)
-        d->fileInfo.setFile(path);
-
-    // return a shallow copy
-    return d->fileInfo;
-}
-
-/*!
-    \fn virtual QString QAbstractFileEngineIterator::next() = 0
+    qint64 writtenBytes = 0;
 
-    This pure virtual function advances the iterator to the next directory
-    entry, and returns the file path to the current entry.
-
-    This function can optionally make use of nameFilters() and filters() to
-    optimize its performance.
-
-    Reimplement this function in a subclass to advance the iterator.
-
-    \sa QDirIterator::next()
-*/
-
-/*!
-    \fn virtual bool QAbstractFileEngineIterator::hasNext() const = 0
-
-    This pure virtual function returns true if there is at least one more
-    entry in the current directory (i.e., the iterator path is valid and
-    accessible, and the iterator has not reached the end of the entry list).
-
-    \sa QDirIterator::hasNext()
-*/
-
-/*!
-    Returns an instance of a QAbstractFileEngineIterator using \a filters for
-    entry filtering and \a filterNames for name filtering. This function is
-    called by QDirIterator to initiate directory iteration.
+    if (d->fd != -1) {
+        ssize_t result;
+        do {
+            result = QT_WRITE(d->fd, data + writtenBytes, size_t(len - writtenBytes));
+        } while ((result == -1 && errno == EINTR)
+                || (result > 0 && (writtenBytes += result) < len));
+    }
 
-    QDirIterator takes ownership of the returned instance, and deletes it when
-    it's done.
+    if (len && writtenBytes == 0) {
+        writtenBytes = -1;
+        setError(errno == ENOSPC ? QFile::ResourceError : QFile::WriteError, qt_error_string(errno));
+    }
 
-    \sa QDirIterator
-*/
-QAbstractFileEngine::Iterator *QAbstractFileEngine::beginEntryList(QDir::Filters filters, const QStringList &filterNames)
-{
-    Q_UNUSED(filters);
-    Q_UNUSED(filterNames);
-    return 0;
-}
+    d->metaData.clearFlags(QFileSystemMetaData::SizeAttribute);
 
-/*!
-    \internal
-*/
-QAbstractFileEngine::Iterator *QAbstractFileEngine::endEntryList()
-{
-    return 0;
-}
-
-/*!
-    Reads a number of characters from the file into \a data. At most
-    \a maxlen characters will be read.
-
-    Returns -1 if a fatal error occurs, or 0 if there are no bytes to
-    read.
-*/
-qint64 QAbstractFileEngine::read(char *data, qint64 maxlen)
-{
-    Q_UNUSED(data);
-    Q_UNUSED(maxlen);
-    return -1;
-}
-
-/*!
-    Writes \a len bytes from \a data to the file. Returns the number
-    of characters written on success; otherwise returns -1.
-*/
-qint64 QAbstractFileEngine::write(const char *data, qint64 len)
-{
-    Q_UNUSED(data);
-    Q_UNUSED(len);
-    return -1;
+    return writtenBytes;
 }
 
 /*!
@@ -912,9 +1132,18 @@ qint64 QAbstractFileEngine::readLine(char *data, qint64 maxlen)
 */
 bool QAbstractFileEngine::extension(Extension extension, const ExtensionOption *option, ExtensionReturn *output)
 {
-    Q_UNUSED(extension);
-    Q_UNUSED(option);
-    Q_UNUSED(output);
+    Q_D(QAbstractFileEngine);
+
+    if (extension == MapExtension) {
+        const MapExtensionOption *options = (MapExtensionOption*)(option);
+        MapExtensionReturn *returnValue = static_cast<MapExtensionReturn*>(output);
+        returnValue->address = d->map(options->offset, options->size);
+        return (returnValue->address != 0);
+    } else if (extension == UnMapExtension) {
+        UnMapExtensionOption *options = (UnMapExtensionOption*)option;
+        return d->unmap(options->address);
+    }
+
     return false;
 }
 
@@ -929,16 +1158,20 @@ bool QAbstractFileEngine::extension(Extension extension, const ExtensionOption *
 */
 bool QAbstractFileEngine::supportsExtension(Extension extension) const
 {
-    Q_UNUSED(extension);
+    Q_D(const QAbstractFileEngine);
+    if (extension == FastReadLineExtension && d->fd != -1 && isSequential())
+        return true;
+    if (extension == UnMapExtension || extension == MapExtension)
+        return true;
     return false;
 }
 
 /*!
-  Returns the QFile::FileError that resulted from the last failed
-  operation. If QFile::UnspecifiedError is returned, QFile will
-  use its own idea of the error status.
+    Returns the QFile::FileError that resulted from the last failed
+    operation. If QFile::UnspecifiedError is returned, QFile will
+    use its own idea of the error status.
 
-  \sa QFile::FileError, errorString()
+    \sa QFile::FileError, errorString()
  */
 QFile::FileError QAbstractFileEngine::error() const
 {
@@ -947,11 +1180,11 @@ QFile::FileError QAbstractFileEngine::error() const
 }
 
 /*!
-  Returns the human-readable message appropriate to the current error
-  reported by error(). If no suitable string is available, an
-  empty string is returned.
+    Returns the human-readable message appropriate to the current error
+    reported by error(). If no suitable string is available, an
+    empty string is returned.
 
-  \sa error()
+    \sa error()
  */
 QString QAbstractFileEngine::errorString() const
 {
@@ -973,4 +1206,344 @@ void QAbstractFileEngine::setError(QFile::FileError error, const QString &errorS
     d->errorString = errorString;
 }
 
+/*!
+    Opens the file descriptor \a fd in \a openMode mode. Returns true
+    on success; otherwise returns false.
+
+    The \a handleFlags argument specifies whether the file handle will be
+    closed by Katie. See the QFile::FileHandleFlags documentation for more
+    information.
+*/
+bool QAbstractFileEngine::open(QIODevice::OpenMode openMode, int fd, QFile::FileHandleFlags handleFlags)
+{
+    Q_D(QAbstractFileEngine);
+
+    // Append implies WriteOnly.
+    if (openMode & QFile::Append)
+        openMode |= QFile::WriteOnly;
+
+    // WriteOnly implies Truncate if neither ReadOnly nor Append are sent.
+    if ((openMode & QFile::WriteOnly) && !(openMode & (QFile::ReadOnly | QFile::Append)))
+        openMode |= QFile::Truncate;
+
+    d->openMode = openMode;
+    d->closeFileHandle = (handleFlags & QFile::AutoCloseHandle);
+    d->fileEntry.clear();
+    d->fd = fd;
+    d->metaData.clear();
+
+    // Seek to the end when in Append mode.
+    if (d->openMode & QFile::Append) {
+        if (QT_LSEEK(d->fd, 0, SEEK_END) == -1) {
+            setError(errno == EMFILE ? QFile::ResourceError : QFile::OpenError,
+                     qt_error_string(errno));
+            if (d->closeFileHandle) {
+                qt_safe_close(d->fd);
+            }
+            d->openMode = QIODevice::NotOpen;
+            d->fd = -1;
+            return false;
+        }
+    }
+
+    return true;
+}
+
+
+QString QAbstractFileEngine::currentPath(const QString &)
+{
+    return QFileSystemEngine::currentPath().filePath();
+}
+
+QString QAbstractFileEngine::homePath()
+{
+    return QFileSystemEngine::homePath();
+}
+
+QString QAbstractFileEngine::rootPath()
+{
+    return QFileSystemEngine::rootPath();
+}
+
+QString QAbstractFileEngine::tempPath()
+{
+    return QFileSystemEngine::tempPath();
+}
+
+/*!
+    \since 4.3
+    \class QAbstractFileEngineIterator
+    \brief The QAbstractFileEngineIterator class provides an iterator
+    interface for custom file engines.
+
+    If all you want is to iterate over entries in a directory, see
+    QDirIterator instead. This class is only for custom file engine authors.
+
+    QAbstractFileEngineIterator is a unidirectional single-use virtual
+    iterator that plugs into QDirIterator, providing transparent proxy
+    iteration for custom file engines.
+
+    You can subclass QAbstractFileEngineIterator to provide an iterator when
+    writing your own file engine. To plug the iterator into your file system,
+    you simply return an instance of this subclass from a reimplementation of
+    QAbstractFileEngine::beginEntryList().
+
+    Example:
+
+    \snippet doc/src/snippets/code/src_corelib_io_qabstractfileengine.cpp 2
+
+    QAbstractFileEngineIterator is associated with a path, name filters, and
+    entry filters. The path is the directory that the iterator lists entries
+    in. The name filters and entry filters are provided for file engines that
+    can optimize directory listing at the iterator level (e.g., network file
+    systems that need to minimize network traffic), but they can also be
+    ignored by the iterator subclass; QAbstractFileEngineIterator already
+    provides the required filtering logics in the matchesFilters() function.
+    You can call dirName() to get the directory name, nameFilters() to get a
+    stringlist of name filters, and filters() to get the entry filters.
+
+    The pure virtual function hasNext() returns true if the current directory
+    has at least one more entry (i.e., the directory name is valid and
+    accessible, and we have not reached the end of the entry list), and false
+    otherwise. Reimplement next() to seek to the next entry.
+
+    The pure virtual function currentFileName() returns the name of the
+    current entry without advancing the iterator. The currentFilePath()
+    function is provided for convenience; it returns the full path of the
+    current entry.
+
+    Here is an example of how to implement an iterator that returns each of
+    three fixed entries in sequence.
+
+    \snippet doc/src/snippets/code/src_corelib_io_qabstractfileengine.cpp 3
+
+    Note: QAbstractFileEngineIterator does not deal with QDir::IteratorFlags;
+    it simply returns entries for a single directory.
+
+    \sa QDirIterator
+*/
+
+/*!
+    \typedef QAbstractFileEngine::Iterator
+    \since 4.3
+    \relates QAbstractFileEngine
+
+    Synonym for QAbstractFileEngineIterator.
+*/
+
+class QAbstractFileEngineIteratorPrivate
+{
+public:
+    QAbstractFileEngineIteratorPrivate();
+    ~QAbstractFileEngineIteratorPrivate();
+
+    QString path;
+    QDir::Filters filters;
+    QStringList nameFilters;
+    QFileInfo fileInfo;
+
+#ifndef QT_NO_FILESYSTEMITERATOR
+    void advance() const;
+
+    mutable QFileSystemIterator* nativeIterator;
+    mutable QFileInfo currentInfo;
+    mutable QFileInfo nextInfo;
+    mutable bool done;
+#endif
+};
+
+QAbstractFileEngineIteratorPrivate::QAbstractFileEngineIteratorPrivate()
+#ifndef QT_NO_FILESYSTEMITERATOR
+    : nativeIterator(nullptr)
+    , done(false)
+#endif
+{
+}
+
+QAbstractFileEngineIteratorPrivate::~QAbstractFileEngineIteratorPrivate()
+{
+#ifndef QT_NO_FILESYSTEMITERATOR
+    delete nativeIterator;
+#endif
+}
+
+#ifndef QT_NO_FILESYSTEMITERATOR
+void QAbstractFileEngineIteratorPrivate::advance() const
+{
+    currentInfo = nextInfo;
+
+    QFileSystemEntry entry;
+    QFileSystemMetaData data;
+    if (nativeIterator->advance(entry, data)) {
+        nextInfo = QFileInfo(new QFileInfoPrivate(entry, data));
+    } else {
+        done = true;
+        delete nativeIterator;
+        nativeIterator = nullptr;
+    }
+}
+#endif // QT_NO_FILESYSTEMITERATOR
+
+/*!
+    Constructs a QAbstractFileEngineIterator, using the entry filters \a
+    filters, and wildcard name filters \a nameFilters.
+*/
+QAbstractFileEngineIterator::QAbstractFileEngineIterator(QDir::Filters filters,
+                                                         const QStringList &nameFilters)
+    : d(new QAbstractFileEngineIteratorPrivate())
+{
+    d->nameFilters = nameFilters;
+    d->filters = filters;
+}
+
+/*!
+    Destroys the QAbstractFileEngineIterator.
+
+    \sa QDirIterator
+*/
+QAbstractFileEngineIterator::~QAbstractFileEngineIterator()
+{
+    delete d;
+}
+
+/*!
+    Returns the path for this iterator. QDirIterator is responsible for
+    assigning this path; it cannot change during the iterator's lifetime.
+
+    \sa nameFilters(), filters()
+*/
+QString QAbstractFileEngineIterator::path() const
+{
+    return d->path;
+}
+
+/*!
+    \internal
+
+    Sets the iterator path to \a path. This function is called from within
+    QDirIterator.
+*/
+void QAbstractFileEngineIterator::setPath(const QString &path)
+{
+    d->path = path;
+}
+
+/*!
+    Returns the name filters for this iterator.
+
+    \sa QDir::nameFilters(), filters(), path()
+*/
+QStringList QAbstractFileEngineIterator::nameFilters() const
+{
+    return d->nameFilters;
+}
+
+/*!
+    Returns the entry filters for this iterator.
+
+    \sa QDir::filter(), nameFilters(), path()
+*/
+QDir::Filters QAbstractFileEngineIterator::filters() const
+{
+    return d->filters;
+}
+
+/*!
+    This pure virtual function returns the name of the current directory
+    entry, excluding the path.
+
+    \sa currentFilePath()
+*/
+QString QAbstractFileEngineIterator::currentFileName() const
+{
+#ifndef QT_NO_FILESYSTEMITERATOR
+    return d->currentInfo.fileName();
+#else
+    return QString();
+#endif
+}
+
+/*!
+    Returns the path to the current directory entry. It's the same as
+    prepending path() to the return value of currentFileName().
+
+    \sa currentFileName()
+*/
+QString QAbstractFileEngineIterator::currentFilePath() const
+{
+    QString name = currentFileName();
+    if (!name.isNull()) {
+        QString tmp = path();
+        if (!tmp.isEmpty()) {
+            if (!tmp.endsWith(QLatin1Char('/')))
+                tmp.append(QLatin1Char('/'));
+            name.prepend(tmp);
+        }
+    }
+    return name;
+}
+
+/*!
+    The virtual function returns a QFileInfo for the current directory
+    entry. This function is provided for convenience. It can also be slightly
+    faster than creating a QFileInfo object yourself, as the object returned
+    by this function might contain cached information that QFileInfo otherwise
+    would have to access through the file engine.
+
+    \sa currentFileName()
+*/
+QFileInfo QAbstractFileEngineIterator::currentFileInfo() const
+{
+#ifndef QT_NO_FILESYSTEMITERATOR
+    return d->currentInfo;
+#else
+    return QFileInfo();
+#endif
+}
+
+/*!
+    This pure virtual function advances the iterator to the next directory
+    entry, and returns the file path to the current entry.
+
+    This function can optionally make use of nameFilters() and filters() to
+    optimize its performance.
+
+    Reimplement this function in a subclass to advance the iterator.
+
+    \sa QDirIterator::next()
+*/
+QString QAbstractFileEngineIterator::next()
+{
+#ifndef QT_NO_FILESYSTEMITERATOR
+    if (!hasNext())
+        return QString();
+
+    d->advance();
+    return currentFilePath();
+#else
+    return QString();
+#endif
+}
+
+/*!
+    This pure virtual function returns true if there is at least one more
+    entry in the current directory (i.e., the iterator path is valid and
+    accessible, and the iterator has not reached the end of the entry list).
+
+    \sa QDirIterator::hasNext()
+*/
+bool QAbstractFileEngineIterator::hasNext() const
+{
+#ifndef QT_NO_FILESYSTEMITERATOR
+    if (!d->done && !d->nativeIterator) {
+        d->nativeIterator = new QFileSystemIterator(QFileSystemEntry(path()));
+        d->advance();
+    }
+
+    return !d->done;
+#else
+    return false;
+#endif
+}
+
 QT_END_NAMESPACE
index c4823bd..e26c426 100644 (file)
@@ -28,7 +28,6 @@
 #error qabstractfileengine.h must be included before any header file that defines open
 #endif
 
-
 QT_BEGIN_NAMESPACE
 
 class QVariant;
@@ -86,42 +85,42 @@ public:
         AccessTime
     };
 
-    virtual ~QAbstractFileEngine();
-
-    virtual bool open(QIODevice::OpenMode openMode);
-    virtual bool close();
-    virtual bool flush();
-    virtual qint64 size() const;
-    virtual qint64 pos() const;
-    virtual bool seek(qint64 pos);
-    virtual bool isSequential() const;
-    virtual bool remove();
-    virtual bool copy(const QString &newName);
-    virtual bool rename(const QString &newName);
-    virtual bool link(const QString &newName);
-    virtual bool mkdir(const QString &dirName, bool createParentDirectories) const;
-    virtual bool rmdir(const QString &dirName, bool recurseParentDirectories) const;
-    virtual bool setSize(qint64 size);
-    virtual bool isRelativePath() const;
-    virtual QStringList entryList(QDir::Filters filters, const QStringList &filterNames) const;
-    virtual FileFlags fileFlags(FileFlags type=FileInfoAll) const;
-    virtual bool setPermissions(uint perms);
-    virtual QString fileName(FileName file=DefaultName) const;
-    virtual uint ownerId(FileOwner) const;
-    virtual QString owner(FileOwner) const;
-    virtual QDateTime fileTime(FileTime time) const;
-    virtual void setFileName(const QString &file);
-    virtual int handle() const;
+    ~QAbstractFileEngine();
+
+    virtual bool open(QIODevice::OpenMode openMode); // virtual for QTemporaryFile
+    virtual bool close(); // virtual for QTemporaryFile
+    bool flush();
+    qint64 size() const;
+    qint64 pos() const;
+    bool seek(qint64 pos);
+    bool isSequential() const;
+    virtual bool remove(); // virtual for QTemporaryFile
+    bool copy(const QString &newName);
+    virtual bool rename(const QString &newName); // virtual for QTemporaryFile
+    bool link(const QString &newName);
+    bool mkdir(const QString &dirName, bool createParentDirectories) const;
+    bool rmdir(const QString &dirName, bool recurseParentDirectories) const;
+    bool setSize(qint64 size);
+    bool isRelativePath() const;
+    QStringList entryList(QDir::Filters filters, const QStringList &filterNames) const;
+    FileFlags fileFlags(FileFlags type=FileInfoAll) const;
+    bool setPermissions(uint perms);
+    QString fileName(FileName file=DefaultName) const;
+    uint ownerId(FileOwner) const;
+    QString owner(FileOwner) const;
+    QDateTime fileTime(FileTime time) const;
+    virtual void setFileName(const QString &file); // virtual for QTemporaryFile
+    int handle() const;
     uchar *map(qint64 offset, qint64 size);
     bool unmap(uchar *ptr);
 
     typedef QAbstractFileEngineIterator Iterator;
-    virtual Iterator *beginEntryList(QDir::Filters filters, const QStringList &filterNames);
-    virtual Iterator *endEntryList();
+    Iterator *beginEntryList(QDir::Filters filters, const QStringList &filterNames);
+    Iterator *endEntryList();
 
-    virtual qint64 read(char *data, qint64 maxlen);
-    virtual qint64 readLine(char *data, qint64 maxlen);
-    virtual qint64 write(const char *data, qint64 len);
+    qint64 read(char *data, qint64 maxlen);
+    qint64 readLine(char *data, qint64 maxlen);
+    qint64 write(const char *data, qint64 len);
 
     QFile::FileError error() const;
     QString errorString() const;
@@ -151,12 +150,20 @@ public:
         uchar *address;
     };
 
-    virtual bool extension(Extension extension, const ExtensionOption *option = nullptr, ExtensionReturn *output = nullptr);
-    virtual bool supportsExtension(Extension extension) const;
+    bool extension(Extension extension, const ExtensionOption *option = nullptr, ExtensionReturn *output = nullptr);
+    bool supportsExtension(Extension extension) const;
 
     // Factory
     static QAbstractFileEngine *create(const QString &fileName);
 
+    //FS only!!
+    bool open(QIODevice::OpenMode flags, int fd, QFile::FileHandleFlags handleFlags);
+    static bool setCurrentPath(const QString &path);
+    static QString currentPath(const QString &path = QString());
+    static QString homePath();
+    static QString rootPath();
+    static QString tempPath();
+
 protected:
     void setError(QFile::FileError error, const QString &str);
 
@@ -167,8 +174,9 @@ protected:
 private:
     Q_DECLARE_PRIVATE(QAbstractFileEngine)
     Q_DISABLE_COPY(QAbstractFileEngine)
-};
 
+    friend class QFilePrivate;
+};
 Q_DECLARE_OPERATORS_FOR_FLAGS(QAbstractFileEngine::FileFlags)
 
 class QAbstractFileEngineIteratorPrivate;
@@ -176,17 +184,17 @@ class Q_CORE_EXPORT QAbstractFileEngineIterator
 {
 public:
     QAbstractFileEngineIterator(QDir::Filters filters, const QStringList &nameFilters);
-    virtual ~QAbstractFileEngineIterator();
+    ~QAbstractFileEngineIterator();
 
-    virtual QString next() = 0;
-    virtual bool hasNext() const = 0;
+    QString next();
+    bool hasNext() const;
 
     QString path() const;
     QStringList nameFilters() const;
     QDir::Filters filters() const;
 
-    virtual QString currentFileName() const = 0;
-    virtual QFileInfo currentFileInfo() const;
+    QString currentFileName() const;
+    QFileInfo currentFileInfo() const;
     QString currentFilePath() const;
 
 private:
@@ -199,5 +207,4 @@ private:
 
 QT_END_NAMESPACE
 
-
 #endif // QABSTRACTFILEENGINE_H
index 641564b..4660d34 100644 (file)
 //
 
 #include "QtCore/qabstractfileengine.h"
+#include "qfilesystementry_p.h"
+#include "qfilesystemmetadata_p.h"
+#include "qfilesystemiterator_p.h"
+#include "qhash.h"
 
 QT_BEGIN_NAMESPACE
 
@@ -43,14 +47,32 @@ public:
     inline QAbstractFileEnginePrivate()
         : fileError(QFile::UnspecifiedError)
     {
+        init();
     }
-    inline virtual ~QAbstractFileEnginePrivate() { }
 
     QFile::FileError fileError;
     QString errorString;
 
+    QFileSystemEntry fileEntry;
+    QIODevice::OpenMode openMode;
+
+    uchar *map(qint64 offset, qint64 size);
+    bool unmap(uchar *ptr);
+
+    mutable QFileSystemMetaData metaData;
+
+    QHash<uchar *, QPair<int /*offset % PageSize*/, size_t /*length + offset % PageSize*/> > maps;
+    int fd;
+
+    bool closeFileHandle;
+
+    bool doStat(QFileSystemMetaData::MetaDataFlags flags) const;
+
     QAbstractFileEngine *q_ptr;
     Q_DECLARE_PUBLIC(QAbstractFileEngine)
+
+protected:
+    void init();
 };
 
 QT_END_NAMESPACE
index 90e6cae..4118386 100644 (file)
@@ -27,7 +27,6 @@
 #include "qdebug.h"
 #endif
 #include "qdiriterator.h"
-#include "qfsfileengine.h"
 #include "qdatetime.h"
 #include "qstring.h"
 #include "qregexp.h"
index 2484b5d..a4929a9 100644 (file)
@@ -79,7 +79,6 @@
 #include "qfilesystementry_p.h"
 #include "qfilesystemmetadata_p.h"
 #include "qfilesystemengine_p.h"
-#include "qfsfileengine.h"
 #include "qfileinfo_p.h"
 #include "qscopedpointer.h"
 
index cf4697a..f5025a7 100644 (file)
@@ -22,7 +22,6 @@
 #include "qplatformdefs.h"
 #include "qdebug.h"
 #include "qfile.h"
-#include "qfsfileengine.h"
 #include "qtemporaryfile.h"
 #include "qlist.h"
 #include "qfileinfo.h"
@@ -59,9 +58,8 @@ QFilePrivate::openExternalFile(int flags, int fd, QFile::FileHandleFlags handleF
 #else
     delete fileEngine;
     fileEngine = 0;
-    QFSFileEngine *fe = new QFSFileEngine;
-    fileEngine = fe;
-    return fe->open(QIODevice::OpenMode(flags), fd, handleFlags);
+    fileEngine = new QAbstractFileEngine();
+    return fileEngine->open(QIODevice::OpenMode(flags), fd, handleFlags);
 #endif
 }
 
index 67b2d54..c4e8745 100644 (file)
 
 QT_BEGIN_NAMESPACE
 
-
 class QDir;
 class QDateTime;
-class QDirIteratorPrivate;
-class QFSFileEngineIterator;
 class QFileInfoPrivate;
 
 class Q_CORE_EXPORT QFileInfo
 {
     friend class QDirIteratorPrivate;
-    friend class QFSFileEngineIterator;
+    friend class QAbstractFileEngineIteratorPrivate;
 public:
     QFileInfo();
     QFileInfo(const QString &file);
index 7c525da..75e3bc1 100644 (file)
@@ -21,7 +21,6 @@
 
 #include "qplatformdefs.h"
 #include "qfilesystemengine_p.h"
-#include "qfsfileengine.h"
 #include "qfile.h"
 #include "qcore_unix_p.h"
 #include "qcorecommon_p.h"
@@ -476,7 +475,7 @@ QFileSystemEntry QFileSystemEngine::currentPath()
 
 #ifndef QT_NO_DEBUG
     if (result.isEmpty())
-        qWarning("QFSFileEngine::currentPath: " GETCWDFUNCNAME "() failed");
+        qWarning("QAbstractFileEngine::currentPath: " GETCWDFUNCNAME "() failed");
 #endif
 #undef GETCWDFUNCNAME
 
index f87f09b..c539003 100644 (file)
@@ -22,7 +22,6 @@
 #include "qfilesystementry_p.h"
 #include "qdir.h"
 #include "qfile.h"
-#include "qfsfileengine_p.h"
 
 QT_BEGIN_NAMESPACE
 
diff --git a/src/core/io/qfsfileengine.cpp b/src/core/io/qfsfileengine.cpp
deleted file mode 100644 (file)
index 430e914..0000000
+++ /dev/null
@@ -1,554 +0,0 @@
-/****************************************************************************
-**
-** Copyright (C) 2015 The Qt Company Ltd.
-** Copyright (C) 2016 Ivailo Monev
-**
-** This file is part of the QtCore module of the Katie Toolkit.
-**
-** $QT_BEGIN_LICENSE:LGPL$
-**
-** GNU Lesser General Public License Usage
-** This file may be used under the terms of the GNU Lesser
-** General Public License version 2.1 as published by the Free Software
-** Foundation and appearing in the file LICENSE.LGPL included in the
-** packaging of this file.  Please review the following information to
-** ensure the GNU Lesser General Public License version 2.1 requirements
-** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
-**
-** $QT_END_LICENSE$
-**
-****************************************************************************/
-
-#include "qfsfileengine_p.h"
-#include "qfsfileengine_iterator_p.h"
-#include "qfilesystemengine_p.h"
-#include "qdatetime.h"
-#include "qdiriterator.h"
-#include "qset.h"
-#include "qdebug.h"
-#include "qcore_unix_p.h"
-
-#ifndef QT_NO_FSFILEENGINE
-
-#include <errno.h>
-#include <stdio.h>
-#include <stdlib.h>
-
-QT_BEGIN_NAMESPACE
-
-/*! \class QFSFileEngine
-    \brief The QFSFileEngine class implements Qt's default file engine.
-    \since 4.1
-
-    This class is part of the file engine framework in Qt. If you only want to
-    access files or directories, use QFile, QFileInfo or QDir instead.
-
-    QFSFileEngine is the default file engine for accessing regular files. It
-    is provided for convenience; by subclassing this class, you can alter its
-    behavior slightly, without having to write a complete QAbstractFileEngine
-    subclass
-
-    It can also be useful to create a QFSFileEngine object directly if you
-    need to use the local file system inside QAbstractFileEngine::create(), in
-    order to avoid recursion (as higher-level classes tend to call
-    QAbstractFileEngine::create()).
-*/
-
-//**************** QFSFileEnginePrivate
-QFSFileEnginePrivate::QFSFileEnginePrivate() : QAbstractFileEnginePrivate()
-{
-    init();
-}
-
-/*!
-    \internal
-*/
-void QFSFileEnginePrivate::init()
-{
-    metaData.clear();
-    openMode = QIODevice::NotOpen;
-    fd = -1;
-    closeFileHandle = false;
-}
-
-/*!
-    Constructs a QFSFileEngine for the file name \a file.
-*/
-QFSFileEngine::QFSFileEngine(const QString &file)
-    : QAbstractFileEngine(*new QFSFileEnginePrivate)
-{
-    Q_D(QFSFileEngine);
-    d->fileEntry = QFileSystemEntry(file);
-}
-
-/*!
-    Constructs a QFSFileEngine.
-*/
-QFSFileEngine::QFSFileEngine() : QAbstractFileEngine(*new QFSFileEnginePrivate)
-{
-}
-
-/*!
-    \internal
-*/
-QFSFileEngine::QFSFileEngine(QFSFileEnginePrivate &dd)
-    : QAbstractFileEngine(dd)
-{
-}
-
-/*!
-    Destructs the QFSFileEngine.
-*/
-QFSFileEngine::~QFSFileEngine()
-{
-    Q_D(QFSFileEngine);
-    if (d->closeFileHandle) {
-        if (d->fd != -1) {
-            qt_safe_close(d->fd);
-        }
-    }
-    QList<uchar*> keys = d->maps.keys();
-    for (int i = 0; i < keys.count(); ++i)
-        unmap(keys.at(i));
-}
-
-/*!
-    \reimp
-*/
-void QFSFileEngine::setFileName(const QString &file)
-{
-    Q_D(QFSFileEngine);
-    d->init();
-    d->fileEntry = QFileSystemEntry(file);
-}
-
-/*!
-    \reimp
-*/
-bool QFSFileEngine::open(QIODevice::OpenMode openMode)
-{
-    Q_D(QFSFileEngine);
-    if (Q_UNLIKELY(d->fileEntry.isEmpty())) {
-        qWarning("QFSFileEngine::open: No file name specified");
-        setError(QFile::OpenError, QLatin1String("No file name specified"));
-        return false;
-    }
-
-    // Append implies WriteOnly.
-    if (openMode & QFile::Append)
-        openMode |= QFile::WriteOnly;
-
-    // WriteOnly implies Truncate if neither ReadOnly nor Append are sent.
-    if ((openMode & QFile::WriteOnly) && !(openMode & (QFile::ReadOnly | QFile::Append)))
-        openMode |= QFile::Truncate;
-
-    d->openMode = openMode;
-    d->metaData.clear();
-    d->fd = -1;
-
-    int flags = QT_OPEN_RDONLY;
-
-    if ((d->openMode & QFile::ReadWrite) == QFile::ReadWrite) {
-        flags = QT_OPEN_RDWR | QT_OPEN_CREAT;
-    } else if (d->openMode & QFile::WriteOnly) {
-        flags = QT_OPEN_WRONLY | QT_OPEN_CREAT;
-    }
-
-    if (d->openMode & QFile::Append) {
-        flags |= QT_OPEN_APPEND;
-    } else if (d->openMode & QFile::WriteOnly) {
-        if ((d->openMode & QFile::Truncate) || !(d->openMode & QFile::ReadOnly))
-            flags |= QT_OPEN_TRUNC;
-    }
-
-    if (d->openMode & QFile::Unbuffered) {
-#ifdef O_DSYNC
-        flags |= O_DSYNC;
-#else
-        flags |= O_SYNC;
-#endif
-    }
-
-    // Try to open the file.
-    const QByteArray native = d->fileEntry.nativeFilePath();
-    d->fd = qt_safe_open(native.constData(), flags, 0666);
-
-    // On failure, return and report the error.
-    if (d->fd == -1) {
-        setError(errno == EMFILE ? QFile::ResourceError : QFile::OpenError,
-                 qt_error_string(errno));
-        d->openMode = QIODevice::NotOpen;
-        return false;
-    }
-
-    // Refuse to open directories, EISDIR is not a thing (by standards) for
-    // non-write modes.
-    QT_STATBUF statbuf;
-    if (QT_FSTAT(d->fd, &statbuf) == 0 && S_ISDIR(statbuf.st_mode)) {
-        setError(QFile::OpenError, QLatin1String("file to open is a directory"));
-        qt_safe_close(d->fd);
-        d->openMode = QIODevice::NotOpen;
-        d->fd = -1;
-        return false;
-    }
-
-    // Seek to the end when in Append mode.
-    if (d->openMode & QFile::Append) {
-        if (QT_LSEEK(d->fd, 0, SEEK_END) == -1) {
-            setError(errno == EMFILE ? QFile::ResourceError : QFile::OpenError,
-                     qt_error_string(errno));
-            qt_safe_close(d->fd);
-            d->openMode = QIODevice::NotOpen;
-            d->fd = -1;
-            return false;
-        }
-    }
-
-    d->closeFileHandle = true;
-
-    return true;
-}
-
-/*!
-    Opens the file descriptor \a fd in \a openMode mode. Returns true
-    on success; otherwise returns false.
-
-    The \a handleFlags argument specifies whether the file handle will be
-    closed by Katie. See the QFile::FileHandleFlags documentation for more
-    information.
-*/
-bool QFSFileEngine::open(QIODevice::OpenMode openMode, int fd, QFile::FileHandleFlags handleFlags)
-{
-    Q_D(QFSFileEngine);
-
-    // Append implies WriteOnly.
-    if (openMode & QFile::Append)
-        openMode |= QFile::WriteOnly;
-
-    // WriteOnly implies Truncate if neither ReadOnly nor Append are sent.
-    if ((openMode & QFile::WriteOnly) && !(openMode & (QFile::ReadOnly | QFile::Append)))
-        openMode |= QFile::Truncate;
-
-    d->openMode = openMode;
-    d->closeFileHandle = (handleFlags & QFile::AutoCloseHandle);
-    d->fileEntry.clear();
-    d->fd = fd;
-    d->metaData.clear();
-
-    // Seek to the end when in Append mode.
-    if (d->openMode & QFile::Append) {
-        if (QT_LSEEK(d->fd, 0, SEEK_END) == -1) {
-            setError(errno == EMFILE ? QFile::ResourceError : QFile::OpenError,
-                     qt_error_string(errno));
-            if (d->closeFileHandle) {
-                qt_safe_close(d->fd);
-            }
-            d->openMode = QIODevice::NotOpen;
-            d->fd = -1;
-            return false;
-        }
-    }
-
-    return true;
-}
-
-/*!
-    \reimp
-*/
-bool QFSFileEngine::close()
-{
-    Q_D(QFSFileEngine);
-    d->openMode = QIODevice::NotOpen;
-
-    if (d->fd == -1)
-        return false;
-
-    d->metaData.clear();
-
-    // Close the file if we created the handle.
-    if (d->closeFileHandle) {
-        int ret = qt_safe_close(d->fd);
-
-        // We must reset these guys regardless; calling close again after a
-        // failed close causes crashes on some systems.
-        d->fd = -1;
-
-        // Report errors.
-        if (ret != 0) {
-            setError(QFile::UnspecifiedError, qt_error_string(errno));
-            return false;
-        }
-    }
-
-    return true;
-}
-
-/*!
-    \reimp
-*/
-bool QFSFileEngine::flush()
-{
-    Q_D(const QFSFileEngine);
-    return (d->fd != -1);
-}
-
-/*!
-    \reimp
-*/
-qint64 QFSFileEngine::size() const
-{
-    Q_D(const QFSFileEngine);
-
-    if (!d->doStat(QFileSystemMetaData::SizeAttribute))
-        return 0;
-    return d->metaData.size();
-}
-
-/*!
-    \reimp
-*/
-qint64 QFSFileEngine::pos() const
-{
-    Q_D(const QFSFileEngine);
-    return (qint64)QT_LSEEK(d->fd, 0, SEEK_CUR);
-}
-
-/*!
-    \reimp
-*/
-bool QFSFileEngine::seek(qint64 pos)
-{
-    Q_D(QFSFileEngine);
-
-    if (pos < 0 || pos != qint64(QT_OFF_T(pos)))
-        return false;
-
-    if (Q_UNLIKELY(QT_LSEEK(d->fd, QT_OFF_T(pos), SEEK_SET) == -1)) {
-        qWarning() << "QFile::at: Cannot set file position" << pos;
-        setError(QFile::PositionError, qt_error_string(errno));
-        return false;
-    }
-    return true;
-}
-
-/*!
-    \reimp
-*/
-int QFSFileEngine::handle() const
-{
-    Q_D(const QFSFileEngine);
-    return d->fd;
-}
-
-/*!
-    \reimp
-*/
-qint64 QFSFileEngine::read(char *data, qint64 maxlen)
-{
-    Q_D(QFSFileEngine);
-
-    if (maxlen < 0) {
-        setError(QFile::ReadError, qt_error_string(EINVAL));
-        return -1;
-    }
-
-    qint64 readBytes = 0;
-    bool eof = false;
-
-    if (d->fd != -1) {
-        ssize_t result;
-        do {
-            result = QT_READ(d->fd, data + readBytes, size_t(maxlen - readBytes));
-        } while ((result == -1 && errno == EINTR)
-                || (result > 0 && (readBytes += result) < maxlen));
-
-        eof = !(result == -1);
-    }
-
-    if (!eof && readBytes == 0) {
-        readBytes = -1;
-        setError(QFile::ReadError, qt_error_string(errno));
-    }
-
-    return readBytes;
-}
-
-/*!
-    \reimp
-*/
-qint64 QFSFileEngine::write(const char *data, qint64 len)
-{
-    Q_D(QFSFileEngine);
-
-    if (len < 0 || len != qint64(size_t(len))) {
-        setError(QFile::WriteError, qt_error_string(EINVAL));
-        return -1;
-    }
-
-    qint64 writtenBytes = 0;
-
-    if (d->fd != -1) {
-        ssize_t result;
-        do {
-            result = QT_WRITE(d->fd, data + writtenBytes, size_t(len - writtenBytes));
-        } while ((result == -1 && errno == EINTR)
-                || (result > 0 && (writtenBytes += result) < len));
-    }
-
-    if (len && writtenBytes == 0) {
-        writtenBytes = -1;
-        setError(errno == ENOSPC ? QFile::ResourceError : QFile::WriteError, qt_error_string(errno));
-    }
-
-    d->metaData.clearFlags(QFileSystemMetaData::SizeAttribute);
-
-    return writtenBytes;
-}
-
-#ifndef QT_NO_FILESYSTEMITERATOR
-/*!
-    \internal
-*/
-QAbstractFileEngine::Iterator *QFSFileEngine::beginEntryList(QDir::Filters filters, const QStringList &filterNames)
-{
-    return new QFSFileEngineIterator(filters, filterNames);
-}
-#endif
-
-/*!
-    \reimp
-*/
-bool QFSFileEngine::isSequential() const
-{
-    Q_D(const QFSFileEngine);
-    if (d->doStat(QFileSystemMetaData::SequentialType))
-        return d->metaData.isSequential();
-    return true;
-}
-
-/*!
-    \reimp
-*/
-bool QFSFileEngine::extension(Extension extension, const ExtensionOption *option, ExtensionReturn *output)
-{
-    Q_D(QFSFileEngine);
-
-    if (extension == MapExtension) {
-        const MapExtensionOption *options = (MapExtensionOption*)(option);
-        MapExtensionReturn *returnValue = static_cast<MapExtensionReturn*>(output);
-        returnValue->address = d->map(options->offset, options->size);
-        return (returnValue->address != 0);
-    } else if (extension == UnMapExtension) {
-        UnMapExtensionOption *options = (UnMapExtensionOption*)option;
-        return d->unmap(options->address);
-    }
-
-    return false;
-}
-
-/*!
-    \reimp
-*/
-bool QFSFileEngine::supportsExtension(Extension extension) const
-{
-    Q_D(const QFSFileEngine);
-    if (extension == FastReadLineExtension && d->fd != -1 && isSequential())
-        return true;
-    if (extension == UnMapExtension || extension == MapExtension)
-        return true;
-    return false;
-}
-
-/*! \fn bool QFSFileEngine::copy(const QString &copyName)
-
-  Copy the file to file \a copyName.
-*/
-
-/*! \fn QString QFSFileEngine::currentPath(const QString &fileName)
-  For Unix, returns the current working directory for the file
-  engine.
-
-  \sa setCurrentPath()
-*/
-
-/*! \fn QString QFSFileEngine::fileName(FileName file) const
-  \reimp
-*/
-
-/*! \fn QDateTime QFSFileEngine::fileTime(FileTime time) const
-  \reimp
-*/
-
-/*! \fn QString QFSFileEngine::homePath()
-  Returns the home path of the current user.
-
-  \sa rootPath()
-*/
-
-/*! \fn bool QFSFileEngine::isRelativePath() const
-  \reimp
-*/
-
-/*! \fn bool QFSFileEngine::link(const QString &newName)
-
-  Creates a link from the file currently specified by fileName() to
-  \a newName. What a link is depends on the underlying filesystem
-  (be it a shortcut on Windows or a symbolic link on Unix). Returns
-  true if successful; otherwise returns false.
-*/
-
-/*! \fn bool QFSFileEngine::mkdir(const QString &name, bool createParentDirectories) const
-  \reimp
-*/
-
-/*! \fn uint QFSFileEngine::ownerId(FileOwner own) const
-  In Unix, if stat() is successful, the \c uid is returned if
-  \a own is the owner. Otherwise the \c gid is returned. If stat()
-  is unsuccessful, -2 is returned.
-*/
-
-/*! \fn QString QFSFileEngine::owner(FileOwner own) const
-  \reimp
-*/
-
-/*! \fn bool QFSFileEngine::remove()
-  \reimp
-*/
-
-/*! \fn bool QFSFileEngine::rename(const QString &newName)
-  \reimp
-*/
-
-/*! \fn bool QFSFileEngine::rmdir(const QString &name, bool recurseParentDirectories) const
-  \reimp
-*/
-
-/*! \fn QString QFSFileEngine::rootPath()
-  Returns the root path.
-
-  \sa homePath()
-*/
-
-/*! \fn bool QFSFileEngine::setCurrentPath(const QString &path)
-  Sets the current path (e.g., for QDir), to \a path. Returns true if the
-  new path exists; otherwise this function does nothing, and returns false.
-
-  \sa currentPath()
-*/
-
-/*! \fn bool QFSFileEngine::setPermissions(uint perms)
-  \reimp
-*/
-
-/*! \fn bool QFSFileEngine::setSize(qint64 size)
-  \reimp
-*/
-
-/*! \fn QString QFSFileEngine::tempPath()
-  Returns the temporary path (i.e., a path in which it is safe
-  to store temporary files).
-*/
-
-QT_END_NAMESPACE
-
-#endif // QT_NO_FSFILEENGINE
diff --git a/src/core/io/qfsfileengine.h b/src/core/io/qfsfileengine.h
deleted file mode 100644 (file)
index a4674eb..0000000
+++ /dev/null
@@ -1,94 +0,0 @@
-/****************************************************************************
-**
-** Copyright (C) 2015 The Qt Company Ltd.
-** Copyright (C) 2016 Ivailo Monev
-**
-** This file is part of the QtCore module of the Katie Toolkit.
-**
-** $QT_BEGIN_LICENSE:LGPL$
-**
-** GNU Lesser General Public License Usage
-** This file may be used under the terms of the GNU Lesser
-** General Public License version 2.1 as published by the Free Software
-** Foundation and appearing in the file LICENSE.LGPL included in the
-** packaging of this file.  Please review the following information to
-** ensure the GNU Lesser General Public License version 2.1 requirements
-** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
-**
-** $QT_END_LICENSE$
-**
-****************************************************************************/
-
-#ifndef QFSFILEENGINE_H
-#define QFSFILEENGINE_H
-
-#include <QtCore/qabstractfileengine.h>
-
-#ifndef QT_NO_FSFILEENGINE
-
-
-QT_BEGIN_NAMESPACE
-
-
-class QFSFileEnginePrivate;
-
-class Q_CORE_EXPORT QFSFileEngine : public QAbstractFileEngine
-{
-    Q_DECLARE_PRIVATE(QFSFileEngine)
-public:
-    QFSFileEngine();
-    explicit QFSFileEngine(const QString &file);
-    ~QFSFileEngine();
-
-    bool open(QIODevice::OpenMode openMode);
-    bool close();
-    bool flush();
-    qint64 size() const;
-    qint64 pos() const;
-    bool seek(qint64);
-    bool isSequential() const;
-    bool remove();
-    bool copy(const QString &newName);
-    bool rename(const QString &newName);
-    bool link(const QString &newName);
-    bool mkdir(const QString &dirName, bool createParentDirectories) const;
-    bool rmdir(const QString &dirName, bool recurseParentDirectories) const;
-    bool setSize(qint64 size);
-    bool isRelativePath() const;
-    FileFlags fileFlags(FileFlags type) const;
-    bool setPermissions(uint perms);
-    QString fileName(FileName file) const;
-    uint ownerId(FileOwner) const;
-    QString owner(FileOwner) const;
-    QDateTime fileTime(FileTime time) const;
-    void setFileName(const QString &file);
-    int handle() const;
-
-#ifndef QT_NO_FILESYSTEMITERATOR
-    Iterator *beginEntryList(QDir::Filters filters, const QStringList &filterNames);
-#endif
-
-    qint64 read(char *data, qint64 maxlen);
-    qint64 write(const char *data, qint64 len);
-
-    bool extension(Extension extension, const ExtensionOption *option = nullptr, ExtensionReturn *output = nullptr);
-    bool supportsExtension(Extension extension) const;
-
-    //FS only!!
-    bool open(QIODevice::OpenMode flags, int fd, QFile::FileHandleFlags handleFlags);
-    static bool setCurrentPath(const QString &path);
-    static QString currentPath(const QString &path = QString());
-    static QString homePath();
-    static QString rootPath();
-    static QString tempPath();
-
-protected:
-    QFSFileEngine(QFSFileEnginePrivate &dd);
-};
-
-QT_END_NAMESPACE
-
-
-#endif // QT_NO_FSFILEENGINE
-
-#endif // QFSFILEENGINE_H
diff --git a/src/core/io/qfsfileengine_iterator.cpp b/src/core/io/qfsfileengine_iterator.cpp
deleted file mode 100644 (file)
index 4a84ff8..0000000
+++ /dev/null
@@ -1,91 +0,0 @@
-/****************************************************************************
-**
-** Copyright (C) 2015 The Qt Company Ltd.
-** Copyright (C) 2016 Ivailo Monev
-**
-** This file is part of the QtCore module of the Katie Toolkit.
-**
-** $QT_BEGIN_LICENSE:LGPL$
-**
-** GNU Lesser General Public License Usage
-** This file may be used under the terms of the GNU Lesser
-** General Public License version 2.1 as published by the Free Software
-** Foundation and appearing in the file LICENSE.LGPL included in the
-** packaging of this file.  Please review the following information to
-** ensure the GNU Lesser General Public License version 2.1 requirements
-** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
-**
-** $QT_END_LICENSE$
-**
-****************************************************************************/
-
-#include "qfsfileengine_iterator_p.h"
-#include "qfileinfo_p.h"
-#include "qvariant.h"
-
-#ifndef QT_NO_FSFILEENGINE
-#ifndef QT_NO_FILESYSTEMITERATOR
-
-QT_BEGIN_NAMESPACE
-
-QFSFileEngineIterator::QFSFileEngineIterator(QDir::Filters filters, const QStringList &filterNames)
-    : QAbstractFileEngineIterator(filters, filterNames)
-    , nativeIterator(nullptr)
-    , done(false)
-{
-}
-
-QFSFileEngineIterator::~QFSFileEngineIterator()
-{
-    delete nativeIterator;
-}
-
-bool QFSFileEngineIterator::hasNext() const
-{
-    if (!done && !nativeIterator) {
-        nativeIterator = new QFileSystemIterator(QFileSystemEntry(path()));
-        advance();
-    }
-
-    return !done;
-}
-
-QString QFSFileEngineIterator::next()
-{
-    if (!hasNext())
-        return QString();
-
-    advance();
-    return currentFilePath();
-}
-
-void QFSFileEngineIterator::advance() const
-{
-    currentInfo = nextInfo;
-
-    QFileSystemEntry entry;
-    QFileSystemMetaData data;
-    if (nativeIterator->advance(entry, data)) {
-        nextInfo = QFileInfo(new QFileInfoPrivate(entry, data));
-    } else {
-        done = true;
-        delete nativeIterator;
-        nativeIterator = nullptr;
-    }
-}
-
-QString QFSFileEngineIterator::currentFileName() const
-{
-    return currentInfo.fileName();
-}
-
-QFileInfo QFSFileEngineIterator::currentFileInfo() const
-{
-    return currentInfo;
-}
-
-QT_END_NAMESPACE
-
-#endif // QT_NO_FILESYSTEMITERATOR
-
-#endif // QT_NO_FSFILEENGINE
diff --git a/src/core/io/qfsfileengine_iterator_p.h b/src/core/io/qfsfileengine_iterator_p.h
deleted file mode 100644 (file)
index f4b615e..0000000
+++ /dev/null
@@ -1,72 +0,0 @@
-/****************************************************************************
-**
-** Copyright (C) 2015 The Qt Company Ltd.
-** Copyright (C) 2016 Ivailo Monev
-**
-** This file is part of the QtCore module of the Katie Toolkit.
-**
-** $QT_BEGIN_LICENSE:LGPL$
-**
-** GNU Lesser General Public License Usage
-** This file may be used under the terms of the GNU Lesser
-** General Public License version 2.1 as published by the Free Software
-** Foundation and appearing in the file LICENSE.LGPL included in the
-** packaging of this file.  Please review the following information to
-** ensure the GNU Lesser General Public License version 2.1 requirements
-** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
-**
-** $QT_END_LICENSE$
-**
-****************************************************************************/
-
-#ifndef QFSFILEENGINE_ITERATOR_P_H
-#define QFSFILEENGINE_ITERATOR_P_H
-
-//
-//  W A R N I N G
-//  -------------
-//
-// This file is not part of the Katie API.  It exists purely as an
-// implementation detail.  This header file may change from version to
-// version without notice, or even be removed.
-//
-// We mean it.
-//
-
-#include "qabstractfileengine.h"
-#include "qfilesystemiterator_p.h"
-#include "qdir.h"
-
-#ifndef QT_NO_FSFILEENGINE
-#ifndef QT_NO_FILESYSTEMITERATOR
-
-QT_BEGIN_NAMESPACE
-
-class QFSFileEngineIteratorPrivate;
-
-class QFSFileEngineIterator : public QAbstractFileEngineIterator
-{
-public:
-    QFSFileEngineIterator(QDir::Filters filters, const QStringList &filterNames);
-    ~QFSFileEngineIterator();
-
-    QString next();
-    bool hasNext() const;
-
-    QString currentFileName() const;
-    QFileInfo currentFileInfo() const;
-
-private:
-    void advance() const;
-    mutable QFileSystemIterator* nativeIterator;
-    mutable QFileInfo currentInfo;
-    mutable QFileInfo nextInfo;
-    mutable bool done;
-};
-
-QT_END_NAMESPACE
-
-#endif // QT_NO_FILESYSTEMITERATOR
-#endif // QT_NO_FSFILEENGINE
-
-#endif // QFSFILEENGINE_ITERATOR_P_H
diff --git a/src/core/io/qfsfileengine_p.h b/src/core/io/qfsfileengine_p.h
deleted file mode 100644 (file)
index 58b7b7e..0000000
+++ /dev/null
@@ -1,77 +0,0 @@
-/****************************************************************************
-**
-** Copyright (C) 2015 The Qt Company Ltd.
-** Copyright (C) 2016 Ivailo Monev
-**
-** This file is part of the QtCore module of the Katie Toolkit.
-**
-** $QT_BEGIN_LICENSE:LGPL$
-**
-** GNU Lesser General Public License Usage
-** This file may be used under the terms of the GNU Lesser
-** General Public License version 2.1 as published by the Free Software
-** Foundation and appearing in the file LICENSE.LGPL included in the
-** packaging of this file.  Please review the following information to
-** ensure the GNU Lesser General Public License version 2.1 requirements
-** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
-**
-** $QT_END_LICENSE$
-**
-****************************************************************************/
-
-#ifndef QFSFILEENGINE_P_H
-#define QFSFILEENGINE_P_H
-
-//
-//  W A R N I N G
-//  -------------
-//
-// This file is not part of the Katie API.  It exists purely as an
-// implementation detail.  This header file may change from version to
-// version without notice, or even be removed.
-//
-// We mean it.
-//
-
-#include "qplatformdefs.h"
-#include "qfsfileengine.h"
-#include "qabstractfileengine_p.h"
-#include "qfilesystementry_p.h"
-#include "qfilesystemmetadata_p.h"
-#include "qhash.h"
-
-#ifndef QT_NO_FSFILEENGINE
-
-QT_BEGIN_NAMESPACE
-
-class Q_AUTOTEST_EXPORT QFSFileEnginePrivate : public QAbstractFileEnginePrivate
-{
-    Q_DECLARE_PUBLIC(QFSFileEngine)
-
-public:
-    QFileSystemEntry fileEntry;
-    QIODevice::OpenMode openMode;
-
-    uchar *map(qint64 offset, qint64 size);
-    bool unmap(uchar *ptr);
-
-    mutable QFileSystemMetaData metaData;
-
-    QHash<uchar *, QPair<int /*offset % PageSize*/, size_t /*length + offset % PageSize*/> > maps;
-    int fd;
-
-    bool closeFileHandle;
-
-    bool doStat(QFileSystemMetaData::MetaDataFlags flags) const;
-
-protected:
-    QFSFileEnginePrivate();
-
-    void init();
-};
-
-QT_END_NAMESPACE
-
-#endif // QT_NO_FSFILEENGINE
-
-#endif // QFSFILEENGINE_P_H
diff --git a/src/core/io/qfsfileengine_unix.cpp b/src/core/io/qfsfileengine_unix.cpp
deleted file mode 100644 (file)
index bbae10c..0000000
+++ /dev/null
@@ -1,381 +0,0 @@
-/****************************************************************************
-**
-** Copyright (C) 2015 The Qt Company Ltd.
-** Copyright (C) 2016 Ivailo Monev
-**
-** This file is part of the QtCore module of the Katie Toolkit.
-**
-** $QT_BEGIN_LICENSE:LGPL$
-**
-** GNU Lesser General Public License Usage
-** This file may be used under the terms of the GNU Lesser
-** General Public License version 2.1 as published by the Free Software
-** Foundation and appearing in the file LICENSE.LGPL included in the
-** packaging of this file.  Please review the following information to
-** ensure the GNU Lesser General Public License version 2.1 requirements
-** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
-**
-** $QT_END_LICENSE$
-**
-****************************************************************************/
-
-#include "qplatformdefs.h"
-#include "qabstractfileengine.h"
-#include "qfsfileengine_p.h"
-#include "qcore_unix_p.h"
-#include "qfilesystementry_p.h"
-#include "qfilesystemengine_p.h"
-
-#ifndef QT_NO_FSFILEENGINE
-
-#include "qfile.h"
-#include "qdir.h"
-#include "qdatetime.h"
-
-#include <sys/mman.h>
-#include <stdlib.h>
-#include <limits.h>
-#include <errno.h>
-
-QT_BEGIN_NAMESPACE
-
-bool QFSFileEnginePrivate::doStat(QFileSystemMetaData::MetaDataFlags flags) const
-{
-    if (!metaData.hasFlags(flags)) {
-        if (!fileEntry.isEmpty())
-            QFileSystemEngine::fillMetaData(fileEntry, metaData, metaData.missingFlags(flags));
-
-        if (metaData.missingFlags(flags) && fd != -1)
-            QFileSystemEngine::fillMetaData(fd, metaData);
-    }
-
-    return metaData.exists();
-}
-
-uchar *QFSFileEnginePrivate::map(qint64 offset, qint64 size)
-{
-    Q_Q(QFSFileEngine);
-    if (openMode == QIODevice::NotOpen) {
-        q->setError(QFile::PermissionsError, qt_error_string(EACCES));
-        return 0;
-    }
-
-    if (offset < 0 || offset != qint64(QT_OFF_T(offset))
-            || size < 0 || quint64(size) > quint64(size_t(-1))) {
-        q->setError(QFile::UnspecifiedError, qt_error_string(EINVAL));
-        return 0;
-    }
-
-    // If we know the mapping will extend beyond EOF, fail early to avoid
-    // undefined behavior. Otherwise, let mmap have its say.
-    if (doStat(QFileSystemMetaData::SizeAttribute)
-            && (QT_OFF_T(size) > metaData.size() - QT_OFF_T(offset)))
-        qWarning("QFSFileEngine::map: Mapping a file beyond its size is not portable");
-
-    int access = 0;
-    if (openMode & QIODevice::ReadOnly) access |= PROT_READ;
-    if (openMode & QIODevice::WriteOnly) access |= PROT_WRITE;
-
-    static const int pageSize = ::getpagesize();
-    const int extra = offset % pageSize;
-
-    if (quint64(size + extra) > quint64((size_t)-1)) {
-        q->setError(QFile::UnspecifiedError, qt_error_string(EINVAL));
-        return 0;
-    }
-
-    size_t realSize = (size_t)size + extra;
-    QT_OFF_T realOffset = QT_OFF_T(offset);
-    realOffset &= ~(QT_OFF_T(pageSize - 1));
-
-    void *mapAddress = QT_MMAP(nullptr, realSize,
-                   access, MAP_SHARED, fd, realOffset);
-    if (mapAddress != MAP_FAILED) {
-        uchar *address = extra + static_cast<uchar*>(mapAddress);
-        maps[address] = QPair<int,size_t>(extra, realSize);
-        return address;
-    }
-
-    switch(errno) {
-    case EBADF:
-        q->setError(QFile::PermissionsError, qt_error_string(EACCES));
-        break;
-    case ENFILE:
-    case ENOMEM:
-        q->setError(QFile::ResourceError, qt_error_string(errno));
-        break;
-    case EINVAL:
-        // size are out of bounds
-    default:
-        q->setError(QFile::UnspecifiedError, qt_error_string(errno));
-        break;
-    }
-    return 0;
-}
-
-bool QFSFileEnginePrivate::unmap(uchar *ptr)
-{
-    Q_Q(QFSFileEngine);
-    if (!maps.contains(ptr)) {
-        q->setError(QFile::PermissionsError, qt_error_string(EACCES));
-        return false;
-    }
-
-    uchar *start = ptr - maps[ptr].first;
-    size_t len = maps[ptr].second;
-    if (::munmap(start, len) == -1) {
-        q->setError(QFile::UnspecifiedError, qt_error_string(errno));
-        return false;
-    }
-    maps.remove(ptr);
-    return true;
-}
-
-bool QFSFileEngine::remove()
-{
-    Q_D(QFSFileEngine);
-    int error;
-    bool ret = QFileSystemEngine::removeFile(d->fileEntry, &error);
-    d->metaData.clear();
-    if (!ret) {
-        setError(QFile::RemoveError, qt_error_string(error));
-    }
-    return ret;
-}
-
-bool QFSFileEngine::copy(const QString &newName)
-{
-    Q_D(QFSFileEngine);
-    int error;
-    bool ret = QFileSystemEngine::copyFile(d->fileEntry, QFileSystemEntry(newName), &error);
-    if (!ret) {
-        setError(QFile::CopyError, qt_error_string(error));
-    }
-    return ret;
-}
-
-bool QFSFileEngine::rename(const QString &newName)
-{
-    Q_D(QFSFileEngine);
-    int error;
-    bool ret = QFileSystemEngine::renameFile(d->fileEntry, QFileSystemEntry(newName), &error);
-    d->metaData.clear();
-    if (!ret) {
-        setError(QFile::RenameError, qt_error_string(error));
-    }
-
-    return ret;
-}
-
-bool QFSFileEngine::link(const QString &newName)
-{
-    Q_D(QFSFileEngine);
-    int error;
-    bool ret = QFileSystemEngine::createLink(d->fileEntry, QFileSystemEntry(newName), &error);
-    if (!ret) {
-        setError(QFile::RenameError, qt_error_string(error));
-    }
-    return ret;
-}
-
-bool QFSFileEngine::mkdir(const QString &name, bool createParentDirectories) const
-{
-    return QFileSystemEngine::createDirectory(QFileSystemEntry(name), createParentDirectories);
-}
-
-bool QFSFileEngine::rmdir(const QString &name, bool recurseParentDirectories) const
-{
-    return QFileSystemEngine::removeDirectory(QFileSystemEntry(name), recurseParentDirectories);
-}
-
-bool QFSFileEngine::setCurrentPath(const QString &path)
-{
-    return QFileSystemEngine::setCurrentPath(QFileSystemEntry(path));
-}
-
-QString QFSFileEngine::currentPath(const QString &)
-{
-    return QFileSystemEngine::currentPath().filePath();
-}
-
-QString QFSFileEngine::homePath()
-{
-    return QFileSystemEngine::homePath();
-}
-
-QString QFSFileEngine::rootPath()
-{
-    return QFileSystemEngine::rootPath();
-}
-
-QString QFSFileEngine::tempPath()
-{
-    return QFileSystemEngine::tempPath();
-}
-
-/*!
-    \reimp
-*/
-QAbstractFileEngine::FileFlags QFSFileEngine::fileFlags(FileFlags type) const
-{
-    Q_D(const QFSFileEngine);
-
-    if (type & Refresh)
-        d->metaData.clear();
-
-    QAbstractFileEngine::FileFlags ret = 0;
-
-    if (type & FlagsMask)
-        ret |= LocalDiskFlag;
-
-    QFileSystemMetaData::MetaDataFlags queryFlags =
-            QFileSystemMetaData::MetaDataFlags(uint(type))
-            & QFileSystemMetaData::Permissions;
-    queryFlags |= QFileSystemMetaData::LinkType;
-
-    if (type & TypesMask)
-        queryFlags |= QFileSystemMetaData::LinkType
-                | QFileSystemMetaData::FileType
-                | QFileSystemMetaData::DirectoryType;
-
-    if (type & FlagsMask)
-        queryFlags |= QFileSystemMetaData::HiddenAttribute
-                | QFileSystemMetaData::ExistsAttribute;
-
-    bool exists = d->doStat(queryFlags);
-
-    if (!exists && !d->metaData.isLink())
-        return ret;
-
-    if (exists && (type & PermsMask))
-        ret |= FileFlags(uint(d->metaData.permissions()));
-
-    if (type & TypesMask) {
-        if ((type & LinkType) && d->metaData.isLink())
-            ret |= LinkType;
-        if (exists) {
-            if (d->metaData.isFile()) {
-                ret |= FileType;
-            } else if (d->metaData.isDirectory()) {
-                ret |= DirectoryType;
-            }
-        }
-    }
-
-    if (type & FlagsMask) {
-        if (exists)
-            ret |= ExistsFlag;
-        if (d->fileEntry.isRoot())
-            ret |= RootFlag;
-        else if (d->metaData.isHidden())
-            ret |= HiddenFlag;
-    }
-
-    return ret;
-}
-
-QString QFSFileEngine::fileName(FileName file) const
-{
-    Q_D(const QFSFileEngine);
-    if (file == BaseName) {
-        return d->fileEntry.fileName();
-    } else if (file == PathName) {
-        return d->fileEntry.path();
-    } else if (file == AbsoluteName || file == AbsolutePathName) {
-        QFileSystemEntry entry(QFileSystemEngine::absoluteName(d->fileEntry));
-        if (file == AbsolutePathName) {
-            return entry.path();
-        }
-        return entry.filePath();
-    } else if (file == CanonicalName || file == CanonicalPathName) {
-        QFileSystemEntry entry(QFileSystemEngine::canonicalName(d->fileEntry, d->metaData));
-        if (file == CanonicalPathName)
-            return entry.path();
-        return entry.filePath();
-    } else if (file == LinkName) {
-        if (!d->metaData.hasFlags(QFileSystemMetaData::LinkType))
-            QFileSystemEngine::fillMetaData(d->fileEntry, d->metaData, QFileSystemMetaData::LinkType);
-        if (d->metaData.isLink()) {
-            QFileSystemEntry entry = QFileSystemEngine::getLinkTarget(d->fileEntry, d->metaData);
-            return entry.filePath();
-        }
-        return QString();
-    }
-    return d->fileEntry.filePath();
-}
-
-bool QFSFileEngine::isRelativePath() const
-{
-    Q_D(const QFSFileEngine);
-    return d->fileEntry.filePath().length() ? d->fileEntry.filePath()[0] != QLatin1Char('/') : true;
-}
-
-uint QFSFileEngine::ownerId(FileOwner own) const
-{
-    Q_D(const QFSFileEngine);
-
-    if (d->doStat(QFileSystemMetaData::OwnerIds)) {
-        if (own == QAbstractFileEngine::OwnerUser)
-            return d->metaData.userId();
-        return d->metaData.groupId();
-    }
-
-    return QFileSystemMetaData::nobodyID;
-}
-
-QString QFSFileEngine::owner(FileOwner own) const
-{
-    if (own == QAbstractFileEngine::OwnerUser)
-        return QFileSystemEngine::resolveUserName(ownerId(own));
-    return QFileSystemEngine::resolveGroupName(ownerId(own));
-}
-
-bool QFSFileEngine::setPermissions(uint perms)
-{
-    Q_D(QFSFileEngine);
-    int error;
-    if (!QFileSystemEngine::setPermissions(d->fileEntry, QFile::Permissions(perms), &error)) {
-        setError(QFile::PermissionsError, qt_error_string(error));
-        return false;
-    }
-    return true;
-}
-
-bool QFSFileEngine::setSize(qint64 size)
-{
-    Q_D(QFSFileEngine);
-    int ret = 0;
-    if (d->fd != -1) {
-        Q_EINTR_LOOP(ret, QT_FTRUNCATE(d->fd, size));
-    } else {
-        Q_EINTR_LOOP(ret, QT_TRUNCATE(d->fileEntry.nativeFilePath().constData(), size));
-    }
-    d->metaData.clearFlags(QFileSystemMetaData::SizeAttribute);
-    if (ret == -1) {
-        setError(QFile::ResizeError, qt_error_string(errno));
-        return false;
-    }
-    return true;
-}
-
-QDateTime QFSFileEngine::fileTime(FileTime time) const
-{
-    Q_D(const QFSFileEngine);
-
-    if (d->doStat(QFileSystemMetaData::Times)) {
-        switch (time) {
-        case QAbstractFileEngine::ModificationTime:
-            return d->metaData.modificationTime();
-        case QAbstractFileEngine::AccessTime:
-            return d->metaData.accessTime();
-        case QAbstractFileEngine::CreationTime:
-            return d->metaData.creationTime();
-        }
-    }
-
-    return QDateTime();
-}
-
-QT_END_NAMESPACE
-
-#endif // QT_NO_FSFILEENGINE
index 12df677..689e5e1 100644 (file)
@@ -25,7 +25,7 @@
 
 #include "qplatformdefs.h"
 #include "qfile_p.h"
-#include "qfsfileengine_p.h"
+#include "qabstractfileengine_p.h"
 #include "qfilesystemengine_p.h"
 #include "qcore_unix_p.h"
 #include "qcorecommon_p.h"
 QT_BEGIN_NAMESPACE
 
 //************* QTemporaryFileEngine
-class QTemporaryFileEngine : public QFSFileEngine
+class QTemporaryFileEngine : public QAbstractFileEngine
 {
-    Q_DECLARE_PRIVATE(QFSFileEngine)
+    Q_DECLARE_PRIVATE(QAbstractFileEngine)
 public:
     QTemporaryFileEngine(const QString &file, bool fileIsTemplate = true)
-        : QFSFileEngine(), filePathIsTemplate(fileIsTemplate)
+        : QAbstractFileEngine(), filePathIsTemplate(fileIsTemplate)
     {
-        Q_D(QFSFileEngine);
+        Q_D(QAbstractFileEngine);
         d->fileEntry = QFileSystemEntry(file);
 
         if (!filePathIsTemplate)
-            QFSFileEngine::setFileName(file);
+            QAbstractFileEngine::setFileName(file);
     }
 
     ~QTemporaryFileEngine();
@@ -65,12 +65,12 @@ public:
 
 QTemporaryFileEngine::~QTemporaryFileEngine()
 {
-    QFSFileEngine::close();
+    QAbstractFileEngine::close();
 }
 
 bool QTemporaryFileEngine::isReallyOpen()
 {
-    Q_D(QFSFileEngine);
+    Q_D(QAbstractFileEngine);
     return (d->fd != -1);
 
 }
@@ -78,26 +78,26 @@ bool QTemporaryFileEngine::isReallyOpen()
 void QTemporaryFileEngine::setFileName(const QString &file)
 {
     // Really close the file, so we don't leak
-    QFSFileEngine::close();
-    QFSFileEngine::setFileName(file);
+    QAbstractFileEngine::close();
+    QAbstractFileEngine::setFileName(file);
 }
 
 void QTemporaryFileEngine::setFileTemplate(const QString &fileTemplate)
 {
-    Q_D(QFSFileEngine);
+    Q_D(QAbstractFileEngine);
     if (filePathIsTemplate)
         d->fileEntry = QFileSystemEntry(fileTemplate);
 }
 
 bool QTemporaryFileEngine::open(QIODevice::OpenMode openMode)
 {
-    Q_D(QFSFileEngine);
+    Q_D(QAbstractFileEngine);
     Q_ASSERT(!isReallyOpen());
 
     openMode |= QIODevice::ReadWrite;
 
     if (!filePathIsTemplate)
-        return QFSFileEngine::open(openMode);
+        return QAbstractFileEngine::open(openMode);
 
     QString qfilename = d->fileEntry.filePath();
 
@@ -166,11 +166,11 @@ bool QTemporaryFileEngine::open(QIODevice::OpenMode openMode)
 
 bool QTemporaryFileEngine::remove()
 {
-    Q_D(QFSFileEngine);
+    Q_D(QAbstractFileEngine);
     // Since the QTemporaryFileEngine::close() does not really close the file,
-    // we must explicitly call QFSFileEngine::close() before we remove it.
-    QFSFileEngine::close();
-    if (QFSFileEngine::remove()) {
+    // we must explicitly call QAbstractFileEngine::close() before we remove it.
+    QAbstractFileEngine::close();
+    if (QAbstractFileEngine::remove()) {
         d->fileEntry.clear();
         return true;
     }
@@ -179,8 +179,8 @@ bool QTemporaryFileEngine::remove()
 
 bool QTemporaryFileEngine::rename(const QString &newName)
 {
-    QFSFileEngine::close();
-    return QFSFileEngine::rename(newName);
+    QAbstractFileEngine::close();
+    return QAbstractFileEngine::rename(newName);
 }
 
 bool QTemporaryFileEngine::close()
index 349d6fb..be07504 100644 (file)
@@ -21,7 +21,6 @@
 
 #include "qfileinfogatherer_p.h"
 #include "qdebug.h"
-#include "qfsfileengine.h"
 #include "qdiriterator.h"
 
 QT_BEGIN_NAMESPACE
index 9ad3be9..1fd4771 100644 (file)
@@ -58,13 +58,10 @@ set(BOOTSTRAP_SOURCES
     ${CMAKE_SOURCE_DIR}/src/core/io/qfile.cpp
     ${CMAKE_SOURCE_DIR}/src/core/io/qfileinfo.cpp
     ${CMAKE_SOURCE_DIR}/src/core/io/qfilesystementry.cpp
-    ${CMAKE_SOURCE_DIR}/src/core/io/qfsfileengine.cpp
-    ${CMAKE_SOURCE_DIR}/src/core/io/qfsfileengine_iterator.cpp
     ${CMAKE_SOURCE_DIR}/src/core/io/qiodevice.cpp
     ${CMAKE_SOURCE_DIR}/src/core/io/qtextstream.cpp
     ${CMAKE_SOURCE_DIR}/src/core/io/qfilesystemengine_unix.cpp
     ${CMAKE_SOURCE_DIR}/src/core/io/qfilesystemiterator_unix.cpp
-    ${CMAKE_SOURCE_DIR}/src/core/io/qfsfileengine_unix.cpp
     ${CMAKE_SOURCE_DIR}/src/core/kernel/qmetatype.cpp
     ${CMAKE_SOURCE_DIR}/src/core/tools/qbitarray.cpp
     ${CMAKE_SOURCE_DIR}/src/core/tools/qbytearray.cpp
index 6e64f8b..6bc03b9 100644 (file)
@@ -190,7 +190,6 @@ static const struct ClassTblData {
     { QLatin1String("QErrorMessage"), QLatin1String("QtGui/qerrormessage.h") },
     { QLatin1String("QEvent"), QLatin1String("QtCore/qcoreevent.h") },
     { QLatin1String("QEventLoop"), QLatin1String("QtCore/qeventloop.h") },
-    { QLatin1String("QFSFileEngine"), QLatin1String("QtCore/qfsfileengine.h") },
     { QLatin1String("QFile"), QLatin1String("QtCore/qfile.h") },
     { QLatin1String("QFileDialog"), QLatin1String("QtGui/qfiledialog.h") },
     { QLatin1String("QFileIconProvider"), QLatin1String("QtGui/qfileiconprovider.h") },
index 370e51d..1c0b8ef 100644 (file)
@@ -452,7 +452,7 @@ void tst_QFile::open()
     }
 
     if (filename.isEmpty())
-        QTest::ignoreMessage(QtWarningMsg, "QFSFileEngine::open: No file name specified");
+        QTest::ignoreMessage(QtWarningMsg, "QAbstractFileEngine::open: No file name specified");
 
     if (ok) {
         QVERIFY2(f.open(QIODevice::OpenMode(mode)),
index a46cbf9..1607bd7 100644 (file)
@@ -21,7 +21,6 @@
 
 #include <QDebug>
 #include <QTemporaryFile>
-#include <QFSFileEngine>
 #include <QString>
 #include <QDirIterator>
 #include <qtest.h>
@@ -55,7 +54,6 @@ Q_OBJECT
 public:
     enum BenchmarkType {
         QFileBenchmark = 1,
-        QFSFileEngineBenchmark,
         PosixBenchmark,
         QFileFromPosixBenchmark
     };
@@ -69,19 +67,15 @@ private slots:
     void seek();
 
     void readSmallFiles_QFile();
-    void readSmallFiles_QFSFileEngine();
     void readSmallFiles_posix();
 
     void readSmallFiles_QFile_data();
-    void readSmallFiles_QFSFileEngine_data();
     void readSmallFiles_posix_data();
 
     void readBigFile_QFile_data();
-    void readBigFile_QFSFileEngine_data();
     void readBigFile_posix_data();
 
     void readBigFile_QFile();
-    void readBigFile_QFSFileEngine();
     void readBigFile_posix();
 
     void writeFileSequential_data();
@@ -151,7 +145,6 @@ void tst_qfile::cleanupTestCase()
 }
 
 void tst_qfile::readBigFile_QFile() { readBigFile(); }
-void tst_qfile::readBigFile_QFSFileEngine() { readBigFile(); }
 void tst_qfile::readBigFile_posix() 
 { 
     readBigFile(); 
@@ -166,14 +159,6 @@ void tst_qfile::readBigFile_QFile_data()
 
 }
 
-void tst_qfile::readBigFile_QFSFileEngine_data()
-{
-    readBigFile_data(QFSFileEngineBenchmark, QIODevice::NotOpen, QIODevice::NotOpen);
-    readBigFile_data(QFSFileEngineBenchmark, QIODevice::NotOpen, QIODevice::Unbuffered);
-    readBigFile_data(QFSFileEngineBenchmark, QIODevice::Text, QIODevice::NotOpen);
-    readBigFile_data(QFSFileEngineBenchmark, QIODevice::Text, QIODevice::Unbuffered);
-}
-
 void tst_qfile::readBigFile_posix_data()
 {
     readBigFile_data(PosixBenchmark, QIODevice::NotOpen, QIODevice::NotOpen);
@@ -219,19 +204,8 @@ void tst_qfile::readBigFile()
                 file.reset();
             }
             file.close();
+            break;
         }
-        break;
-        case(QFSFileEngineBenchmark): {
-            QFSFileEngine fse(filename);
-            fse.open(QIODevice::ReadOnly|textMode|bufferedMode);
-            QBENCHMARK {
-                //qWarning() << fse.supportsExtension(QAbstractFileEngine::MapExtension);
-                while(fse.read(buffer, blockSize));
-                fse.seek(0);
-            }
-            fse.close();
-        }
-        break;
         case(PosixBenchmark): {
             QByteArray data = filename.toLocal8Bit();
             const char* cfilename = data.constData();
@@ -242,12 +216,12 @@ void tst_qfile::readBigFile()
                 QT_FSEEK(cfile, 0, SEEK_SET);
             }
             ::fclose(cfile);
+            break;
         }
-        break;
         case(QFileFromPosixBenchmark): {
             // No gain in benchmarking this case
+            break;
         }
-        break;
     }
 
     removeFile();
@@ -258,7 +232,6 @@ void tst_qfile::seek_data()
 {
     QTest::addColumn<tst_qfile::BenchmarkType>("testType");
     QTest::newRow("QFile") << QFileBenchmark;
-    QTest::newRow("QFSFileEngine") << QFSFileEngineBenchmark;
     QTest::newRow("Posix FILE*") << PosixBenchmark;
 }
 
@@ -279,18 +252,8 @@ void tst_qfile::seek()
                 file.seek(seekpos[i]);
             }
             file.close();
+            break;
         }
-        break;
-        case(QFSFileEngineBenchmark): {
-            QFSFileEngine fse(filename);
-            fse.open(QIODevice::ReadOnly);
-            QBENCHMARK {
-                i=(i+1)%sp_size;
-                fse.seek(seekpos[i]);
-            }
-            fse.close();
-        }
-        break;
         case(PosixBenchmark): {
             QByteArray data = filename.toLocal8Bit();
             const char* cfilename = data.constData();
@@ -300,12 +263,12 @@ void tst_qfile::seek()
                 QT_FSEEK(cfile, seekpos[i], SEEK_SET);
             }
             ::fclose(cfile);
+            break;
         }
-        break;
         case(QFileFromPosixBenchmark): {
             // No gain in benchmarking this case
+            break;
         }
-        break;
     }
 
     removeFile();
@@ -315,7 +278,6 @@ void tst_qfile::open_data()
 {
     QTest::addColumn<tst_qfile::BenchmarkType>("testType");
     QTest::newRow("QFile") << QFileBenchmark;
-    QTest::newRow("QFSFileEngine") << QFSFileEngineBenchmark;
     QTest::newRow("Posix FILE*") << PosixBenchmark;
     QTest::newRow("QFile from FILE*") << QFileFromPosixBenchmark;
 }
@@ -333,17 +295,8 @@ void tst_qfile::open()
                 file.open( QIODevice::ReadOnly );
                 file.close();
             }
+            break;
         }
-        break;
-        case(QFSFileEngineBenchmark): {
-            QBENCHMARK {
-                QFSFileEngine fse(filename);
-                fse.open(QIODevice::ReadOnly);
-                fse.close();
-            }
-        }
-        break;
-
         case(PosixBenchmark): {
             // ensure we don't account toLocal8Bit()
             QByteArray data = filename.toLocal8Bit();
@@ -353,8 +306,8 @@ void tst_qfile::open()
                 FILE* cfile = QT_FOPEN(cfilename, "rb");
                 ::fclose(cfile);
             }
+            break;
         }
-        break;
         case(QFileFromPosixBenchmark): {
             // ensure we don't account toLocal8Bit()
             QByteArray data = filename.toLocal8Bit();
@@ -367,8 +320,8 @@ void tst_qfile::open()
                 file.close();
             }
             ::fclose(cfile);
+            break;
         }
-        break;
     }
 
     removeFile();
@@ -376,7 +329,6 @@ void tst_qfile::open()
 
 
 void tst_qfile::readSmallFiles_QFile() { readSmallFiles(); }
-void tst_qfile::readSmallFiles_QFSFileEngine() { readSmallFiles(); }
 void tst_qfile::readSmallFiles_posix() 
 {
     readSmallFiles(); 
@@ -391,14 +343,6 @@ void tst_qfile::readSmallFiles_QFile_data()
 
 }
 
-void tst_qfile::readSmallFiles_QFSFileEngine_data()
-{
-    readSmallFiles_data(QFSFileEngineBenchmark, QIODevice::NotOpen, QIODevice::NotOpen);
-    readSmallFiles_data(QFSFileEngineBenchmark, QIODevice::NotOpen, QIODevice::Unbuffered);
-    readSmallFiles_data(QFSFileEngineBenchmark, QIODevice::Text, QIODevice::NotOpen);
-    readSmallFiles_data(QFSFileEngineBenchmark, QIODevice::Text, QIODevice::Unbuffered);
-}
-
 void tst_qfile::readSmallFiles_posix_data()
 {
     readSmallFiles_data(PosixBenchmark, QIODevice::NotOpen, QIODevice::NotOpen);
@@ -484,28 +428,8 @@ void tst_qfile::readSmallFiles()
                 file->close();
                 delete file;
             }
+            break;
         }
-        break;
-        case(QFSFileEngineBenchmark): {
-            QList<QFSFileEngine*> fileList;
-            Q_FOREACH(QString file, files) {
-                QFSFileEngine *fse = new QFSFileEngine(tmpDirName + QLatin1Char('/') + file);
-                fse->open(QIODevice::ReadOnly|textMode|bufferedMode);
-                fileList.append(fse);
-            }
-
-            QBENCHMARK {
-                Q_FOREACH(QFSFileEngine *fse, fileList) {
-                    while (fse->read(buffer, blockSize));
-                }
-            }
-
-            Q_FOREACH(QFSFileEngine *fse, fileList) {
-                fse->close();
-                delete fse;
-            }
-        }
-        break;
         case(PosixBenchmark): {
             QList<FILE*> fileList;
             Q_FOREACH(QString file, files) {
@@ -523,12 +447,12 @@ void tst_qfile::readSmallFiles()
             Q_FOREACH(FILE* cfile, fileList) {
                 ::fclose(cfile);
             }
+            break;
         }
-        break;
         case(QFileFromPosixBenchmark): {
             // No gain in benchmarking this case
+            break;
         }
-        break;
     }
 
     removeSmallFiles();