Drop file-engine abstraction from public API

This abstraction imposed serious performance penalties and is being
dropped from the public API.

In particular, by allowing file names to be arbitrarily hijacked by
different file engines, and requiring engines to be instantiated in
order to decide, it imposed unnecessary overhead on all file operations.

Another flaw in the design with direct impact on performance is how
engines have no way to provide (or retain) additional information
obtained when querying the filesystem. In many places this has meant
repeated operations on the file system, where useful information is
immediately discarded to be queried again subsequently.

For Qt 4.8 a major refactoring of the code base took place to allow
bypassing the file-engine abstraction in select places, with
considerable performance gains observed. In Qt 5 it is expected we'll be
able to take this further, reaping even more benefits, but the
abstraction has to go.

[Dropping this now does not preclude that virtual file systems make an
appearance in Qt at a later point in Qt 5's lifecycle. Hopefully with a
new and improved abstraction.]

Forward declarations for QFileExtension(Result) were dropped, as the
classes were never used or defined.

Tests using "internalized" classes will only fully run on developer
builds. QFSFileEngine was removed altogether from exception safety test,
as it isn't its intent to test internal API.

Change-Id: Ie910e6c2628be202ea9e05366b091d6d529b246b
Reviewed-by: Thiago Macieira <thiago.macieira@intel.com>
Reviewed-by: Lars Knoll <lars.knoll@nokia.com>

1 files changed, 190 insertions, 1 deletions

diff --git a/src/corelib/io/qabstractfileengine_p.h b/src/corelib/io/qabstractfileengine_p.h
index 08bb7fb097..ae7f56e2d7 100644
--- a/src/corelib/io/qabstractfileengine_p.h
+++ b/src/corelib/io/qabstractfileengine_p.h
@@ -53,11 +53,200 @@
 // We mean it.
 //
 
-#include "QtCore/qabstractfileengine.h"
 #include "QtCore/qfile.h"
+#include "QtCore/qdir.h"
+
+#ifdef open
+#error qabstractfileengine_p.h must be included before any header file that defines open
+#endif
 
 QT_BEGIN_NAMESPACE
 
+class QVariant;
+class QAbstractFileEngineIterator;
+class QAbstractFileEnginePrivate;
+
+class Q_AUTOTEST_EXPORT QAbstractFileEngine
+{
+public:
+    enum FileFlag {
+        //perms (overlaps the QFile::Permission)
+        ReadOwnerPerm = 0x4000, WriteOwnerPerm = 0x2000, ExeOwnerPerm = 0x1000,
+        ReadUserPerm  = 0x0400, WriteUserPerm  = 0x0200, ExeUserPerm  = 0x0100,
+        ReadGroupPerm = 0x0040, WriteGroupPerm = 0x0020, ExeGroupPerm = 0x0010,
+        ReadOtherPerm = 0x0004, WriteOtherPerm = 0x0002, ExeOtherPerm = 0x0001,
+
+        //types
+        LinkType      = 0x10000,
+        FileType      = 0x20000,
+        DirectoryType = 0x40000,
+        BundleType    = 0x80000,
+
+        //flags
+        HiddenFlag     = 0x0100000,
+        LocalDiskFlag  = 0x0200000,
+        ExistsFlag     = 0x0400000,
+        RootFlag       = 0x0800000,
+        Refresh        = 0x1000000,
+
+        //masks
+        PermsMask  = 0x0000FFFF,
+        TypesMask  = 0x000F0000,
+        FlagsMask  = 0x0FF00000,
+        FileInfoAll = FlagsMask | PermsMask | TypesMask
+    };
+    Q_DECLARE_FLAGS(FileFlags, FileFlag)
+
+    enum FileName {
+        DefaultName,
+        BaseName,
+        PathName,
+        AbsoluteName,
+        AbsolutePathName,
+        LinkName,
+        CanonicalName,
+        CanonicalPathName,
+        BundleName,
+        NFileNames = 9
+    };
+    enum FileOwner {
+        OwnerUser,
+        OwnerGroup
+    };
+    enum FileTime {
+        CreationTime,
+        ModificationTime,
+        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 caseSensitive() const;
+    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;
+    bool atEnd() const;
+    uchar *map(qint64 offset, qint64 size, QFile::MemoryMapFlags flags);
+    bool unmap(uchar *ptr);
+
+    typedef QAbstractFileEngineIterator Iterator;
+    virtual Iterator *beginEntryList(QDir::Filters filters, const QStringList &filterNames);
+    virtual Iterator *endEntryList();
+
+    virtual qint64 read(char *data, qint64 maxlen);
+    virtual qint64 readLine(char *data, qint64 maxlen);
+    virtual qint64 write(const char *data, qint64 len);
+
+    QFile::FileError error() const;
+    QString errorString() const;
+
+    enum Extension {
+        AtEndExtension,
+        FastReadLineExtension,
+        MapExtension,
+        UnMapExtension
+    };
+    class ExtensionOption
+    {};
+    class ExtensionReturn
+    {};
+
+    class MapExtensionOption : public ExtensionOption {
+    public:
+        qint64 offset;
+        qint64 size;
+        QFile::MemoryMapFlags flags;
+    };
+    class MapExtensionReturn : public ExtensionReturn {
+    public:
+        uchar *address;
+    };
+
+    class UnMapExtensionOption : public ExtensionOption {
+    public:
+        uchar *address;
+    };
+
+    virtual bool extension(Extension extension, const ExtensionOption *option = 0, ExtensionReturn *output = 0);
+    virtual bool supportsExtension(Extension extension) const;
+
+    // Factory
+    static QAbstractFileEngine *create(const QString &fileName);
+
+protected:
+    void setError(QFile::FileError error, const QString &str);
+
+    QAbstractFileEngine();
+    QAbstractFileEngine(QAbstractFileEnginePrivate &);
+
+    QScopedPointer<QAbstractFileEnginePrivate> d_ptr;
+private:
+    Q_DECLARE_PRIVATE(QAbstractFileEngine)
+    Q_DISABLE_COPY(QAbstractFileEngine)
+};
+
+Q_DECLARE_OPERATORS_FOR_FLAGS(QAbstractFileEngine::FileFlags)
+
+class Q_AUTOTEST_EXPORT QAbstractFileEngineHandler
+{
+public:
+    QAbstractFileEngineHandler();
+    virtual ~QAbstractFileEngineHandler();
+    virtual QAbstractFileEngine *create(const QString &fileName) const = 0;
+};
+
+class QAbstractFileEngineIteratorPrivate;
+class Q_AUTOTEST_EXPORT QAbstractFileEngineIterator
+{
+public:
+    QAbstractFileEngineIterator(QDir::Filters filters, const QStringList &nameFilters);
+    virtual ~QAbstractFileEngineIterator();
+
+    virtual QString next() = 0;
+    virtual bool hasNext() const = 0;
+
+    QString path() const;
+    QStringList nameFilters() const;
+    QDir::Filters filters() const;
+
+    virtual QString currentFileName() const = 0;
+    virtual QFileInfo currentFileInfo() const;
+    QString currentFilePath() const;
+
+protected:
+    enum EntryInfoType {
+    };
+    virtual QVariant entryInfo(EntryInfoType type) const;
+
+private:
+    Q_DISABLE_COPY(QAbstractFileEngineIterator)
+    friend class QDirIterator;
+    friend class QDirIteratorPrivate;
+    void setPath(const QString &path);
+    QScopedPointer<QAbstractFileEngineIteratorPrivate> d;
+};
+
 class QAbstractFileEnginePrivate
 {
 public: