From f23acad20e4d65da377b7b16cfeb0f7e9a0d44b8 Mon Sep 17 00:00:00 2001 From: Ivailo Monev Date: Sat, 29 Oct 2022 21:20:01 +0300 Subject: [PATCH] merge QFSFileEngine into QAbstractFileEngine that finally happened Signed-off-by: Ivailo Monev --- package/freebsd/pkg-plist | 2 - scripts/namefsck.py | 1 - src/core/CMakeLists.txt | 7 - src/core/io/qabstractfileengine.cpp | 1117 +++++++++++++++++++++++-------- src/core/io/qabstractfileengine.h | 89 +-- src/core/io/qabstractfileengine_p.h | 24 +- src/core/io/qdir.cpp | 1 - src/core/io/qdiriterator.cpp | 1 - src/core/io/qfile.cpp | 6 +- src/core/io/qfileinfo.h | 5 +- src/core/io/qfilesystemengine_unix.cpp | 3 +- src/core/io/qfilesystementry.cpp | 1 - src/core/io/qfsfileengine.cpp | 554 --------------- src/core/io/qfsfileengine.h | 94 --- src/core/io/qfsfileengine_iterator.cpp | 91 --- src/core/io/qfsfileengine_iterator_p.h | 72 -- src/core/io/qfsfileengine_p.h | 77 --- src/core/io/qfsfileengine_unix.cpp | 381 ----------- src/core/io/qtemporaryfile.cpp | 38 +- src/gui/dialogs/qfileinfogatherer.cpp | 1 - src/tools/moc/CMakeLists.txt | 3 - src/tools/uic/cpp/cppwriteincludes.cpp | 1 - tests/auto/qfile/tst_qfile.cpp | 2 +- tests/benchmarks/core/io/qfile/main.cpp | 100 +-- 24 files changed, 952 insertions(+), 1719 deletions(-) delete mode 100644 src/core/io/qfsfileengine.cpp delete mode 100644 src/core/io/qfsfileengine.h delete mode 100644 src/core/io/qfsfileengine_iterator.cpp delete mode 100644 src/core/io/qfsfileengine_iterator_p.h delete mode 100644 src/core/io/qfsfileengine_p.h delete mode 100644 src/core/io/qfsfileengine_unix.cpp diff --git a/package/freebsd/pkg-plist b/package/freebsd/pkg-plist index 46d4003a8..63113a3fb 100644 --- a/package/freebsd/pkg-plist +++ b/package/freebsd/pkg-plist @@ -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 diff --git a/scripts/namefsck.py b/scripts/namefsck.py index 355cf1214..479506cb2 100755 --- a/scripts/namefsck.py +++ b/scripts/namefsck.py @@ -207,7 +207,6 @@ classlist = [ "QFontMetricsF", "QFormLayout", "QFrame", - "QFSFileEngine", "QFtp", "QFuture", "QFutureInterface", diff --git a/src/core/CMakeLists.txt b/src/core/CMakeLists.txt index 343a707dc..f489dd0b1 100644 --- a/src/core/CMakeLists.txt +++ b/src/core/CMakeLists.txt @@ -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 diff --git a/src/core/io/qabstractfileengine.cpp b/src/core/io/qabstractfileengine.cpp index 3155992db..d7561e93e 100644 --- a/src/core/io/qabstractfileengine.cpp +++ b/src/core/io/qabstractfileengine.cpp @@ -23,15 +23,125 @@ #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 +#include +#include +#include + 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(mapAddress); + maps[address] = QPair(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 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(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 diff --git a/src/core/io/qabstractfileengine.h b/src/core/io/qabstractfileengine.h index c4823bd87..e26c426ba 100644 --- a/src/core/io/qabstractfileengine.h +++ b/src/core/io/qabstractfileengine.h @@ -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 diff --git a/src/core/io/qabstractfileengine_p.h b/src/core/io/qabstractfileengine_p.h index 641564b1f..4660d3484 100644 --- a/src/core/io/qabstractfileengine_p.h +++ b/src/core/io/qabstractfileengine_p.h @@ -34,6 +34,10 @@ // #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 > maps; + int fd; + + bool closeFileHandle; + + bool doStat(QFileSystemMetaData::MetaDataFlags flags) const; + QAbstractFileEngine *q_ptr; Q_DECLARE_PUBLIC(QAbstractFileEngine) + +protected: + void init(); }; QT_END_NAMESPACE diff --git a/src/core/io/qdir.cpp b/src/core/io/qdir.cpp index 90e6cae59..411838643 100644 --- a/src/core/io/qdir.cpp +++ b/src/core/io/qdir.cpp @@ -27,7 +27,6 @@ #include "qdebug.h" #endif #include "qdiriterator.h" -#include "qfsfileengine.h" #include "qdatetime.h" #include "qstring.h" #include "qregexp.h" diff --git a/src/core/io/qdiriterator.cpp b/src/core/io/qdiriterator.cpp index 2484b5de9..a4929a918 100644 --- a/src/core/io/qdiriterator.cpp +++ b/src/core/io/qdiriterator.cpp @@ -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" diff --git a/src/core/io/qfile.cpp b/src/core/io/qfile.cpp index cf4697a74..f5025a72c 100644 --- a/src/core/io/qfile.cpp +++ b/src/core/io/qfile.cpp @@ -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 } diff --git a/src/core/io/qfileinfo.h b/src/core/io/qfileinfo.h index 67b2d541f..c4e87455d 100644 --- a/src/core/io/qfileinfo.h +++ b/src/core/io/qfileinfo.h @@ -28,17 +28,14 @@ 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); diff --git a/src/core/io/qfilesystemengine_unix.cpp b/src/core/io/qfilesystemengine_unix.cpp index 7c525daef..75e3bc1e3 100644 --- a/src/core/io/qfilesystemengine_unix.cpp +++ b/src/core/io/qfilesystemengine_unix.cpp @@ -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 diff --git a/src/core/io/qfilesystementry.cpp b/src/core/io/qfilesystementry.cpp index f87f09b42..c539003f4 100644 --- a/src/core/io/qfilesystementry.cpp +++ b/src/core/io/qfilesystementry.cpp @@ -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 index 430e9141b..000000000 --- a/src/core/io/qfsfileengine.cpp +++ /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 -#include -#include - -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 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(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 ©Name) - - 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 index a4674eb54..000000000 --- a/src/core/io/qfsfileengine.h +++ /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 - -#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 index 4a84ff841..000000000 --- a/src/core/io/qfsfileengine_iterator.cpp +++ /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 index f4b615ec9..000000000 --- a/src/core/io/qfsfileengine_iterator_p.h +++ /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 index 58b7b7e1a..000000000 --- a/src/core/io/qfsfileengine_p.h +++ /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 > 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 index bbae10c36..000000000 --- a/src/core/io/qfsfileengine_unix.cpp +++ /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 -#include -#include -#include - -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(mapAddress); - maps[address] = QPair(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 diff --git a/src/core/io/qtemporaryfile.cpp b/src/core/io/qtemporaryfile.cpp index 12df6773c..689e5e180 100644 --- a/src/core/io/qtemporaryfile.cpp +++ b/src/core/io/qtemporaryfile.cpp @@ -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" @@ -35,18 +35,18 @@ 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() diff --git a/src/gui/dialogs/qfileinfogatherer.cpp b/src/gui/dialogs/qfileinfogatherer.cpp index 349d6fb7b..be075043c 100644 --- a/src/gui/dialogs/qfileinfogatherer.cpp +++ b/src/gui/dialogs/qfileinfogatherer.cpp @@ -21,7 +21,6 @@ #include "qfileinfogatherer_p.h" #include "qdebug.h" -#include "qfsfileengine.h" #include "qdiriterator.h" QT_BEGIN_NAMESPACE diff --git a/src/tools/moc/CMakeLists.txt b/src/tools/moc/CMakeLists.txt index 9ad3be962..1fd4771de 100644 --- a/src/tools/moc/CMakeLists.txt +++ b/src/tools/moc/CMakeLists.txt @@ -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 diff --git a/src/tools/uic/cpp/cppwriteincludes.cpp b/src/tools/uic/cpp/cppwriteincludes.cpp index 6e64f8b4e..6bc03b9c9 100644 --- a/src/tools/uic/cpp/cppwriteincludes.cpp +++ b/src/tools/uic/cpp/cppwriteincludes.cpp @@ -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") }, diff --git a/tests/auto/qfile/tst_qfile.cpp b/tests/auto/qfile/tst_qfile.cpp index 370e51dfe..1c0b8ef72 100644 --- a/tests/auto/qfile/tst_qfile.cpp +++ b/tests/auto/qfile/tst_qfile.cpp @@ -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)), diff --git a/tests/benchmarks/core/io/qfile/main.cpp b/tests/benchmarks/core/io/qfile/main.cpp index a46cbf96f..1607bd74d 100644 --- a/tests/benchmarks/core/io/qfile/main.cpp +++ b/tests/benchmarks/core/io/qfile/main.cpp @@ -21,7 +21,6 @@ #include #include -#include #include #include #include @@ -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("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("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 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 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(); -- 2.11.0