qabstractfileengine.cpp

Go to the documentation of this file.

// Copyright (C) 2022 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
 
#include "private/qabstractfileengine_p.h"
#include "private/qfsfileengine_p.h"
#ifdef QT_BUILD_CORE_LIB
#include "private/qresource_p.h"
#endif
#include "qdatetime.h"
#include "qreadwritelock.h"
#include "qvariant.h"
// built-in handlers
#include "qdiriterator.h"
#include "qstringbuilder.h"
 
#include <QtCore/private/qfilesystementry_p.h>
#include <QtCore/private/qfilesystemmetadata_p.h>
#include <QtCore/private/qfilesystemengine_p.h>
 
QT_BEGIN_NAMESPACE
 
Q_CONSTINIT static QBasicAtomicInt qt_file_engine_handlers_in_use = Q_BASIC_ATOMIC_INITIALIZER(false);
 
/*
    All application-wide handlers are stored in this list. The mutex must be
    acquired to ensure thread safety.
 */
Q_GLOBAL_STATIC(QReadWriteLock, fileEngineHandlerMutex, QReadWriteLock::Recursive)
Q_CONSTINIT static bool qt_abstractfileenginehandlerlist_shutDown = false;
class QAbstractFileEngineHandlerList : public QList<QAbstractFileEngineHandler *>
{
public:
    ~QAbstractFileEngineHandlerList()
    {
        QWriteLocker locker(fileEngineHandlerMutex());
        qt_abstractfileenginehandlerlist_shutDown = true;
    }
};
Q_GLOBAL_STATIC(QAbstractFileEngineHandlerList, fileEngineHandlers)
 
 
QAbstractFileEngineHandler::QAbstractFileEngineHandler()
{
    QWriteLocker locker(fileEngineHandlerMutex());
    qt_file_engine_handlers_in_use.storeRelaxed(true);
    fileEngineHandlers()->prepend(this);
}
 
QAbstractFileEngineHandler::~QAbstractFileEngineHandler()
{
    QWriteLocker locker(fileEngineHandlerMutex());
    // Remove this handler from the handler list only if the list is valid.
    if (!qt_abstractfileenginehandlerlist_shutDown) {
        QAbstractFileEngineHandlerList *handlers = fileEngineHandlers();
        handlers->removeOne(this);
        if (handlers->isEmpty())
            qt_file_engine_handlers_in_use.storeRelaxed(false);
    }
}
 
/*
   \internal
 
   Handles calls to custom file engine handlers.
*/
QAbstractFileEngine *qt_custom_file_engine_handler_create(const QString &path)
{
    if (qt_file_engine_handlers_in_use.loadRelaxed()) {
        QReadLocker locker(fileEngineHandlerMutex());
 
        // check for registered handlers that can load the file
        for (QAbstractFileEngineHandler *handler : std::as_const(*fileEngineHandlers())) {
            if (QAbstractFileEngine *engine = handler->create(path))
                return engine;
        }
    }
 
    return nullptr;
}
 
QAbstractFileEngine *QAbstractFileEngine::create(const QString &fileName)
{
    QFileSystemEntry entry(fileName);
    QFileSystemMetaData metaData;
    QAbstractFileEngine *engine = QFileSystemEngine::resolveEntryAndCreateLegacyEngine(entry, metaData);
 
#ifndef QT_NO_FSFILEENGINE
    if (!engine)
        // fall back to regular file engine
        return new QFSFileEngine(entry.filePath());
#endif
 
    return engine;
}
 
QAbstractFileEngine::QAbstractFileEngine() : d_ptr(new QAbstractFileEnginePrivate)
{
    d_ptr->q_ptr = this;
}
 
QAbstractFileEngine::QAbstractFileEngine(QAbstractFileEnginePrivate &dd) : d_ptr(&dd)
{
    d_ptr->q_ptr = this;
}
 
QAbstractFileEngine::~QAbstractFileEngine()
{
}
 
bool QAbstractFileEngine::open(QIODevice::OpenMode openMode,
                               std::optional<QFile::Permissions> permissions)
{
    Q_UNUSED(openMode);
    Q_UNUSED(permissions);
    return false;
}
 
bool QAbstractFileEngine::close()
{
    return false;
}
 
bool QAbstractFileEngine::syncToDisk()
{
    return false;
}
 
bool QAbstractFileEngine::flush()
{
    return false;
}
 
qint64 QAbstractFileEngine::size() const
{
    return 0;
}
 
qint64 QAbstractFileEngine::pos() const
{
    return 0;
}
 
bool QAbstractFileEngine::seek(qint64 pos)
{
    Q_UNUSED(pos);
    return false;
}
 
bool QAbstractFileEngine::isSequential() const
{
    return false;
}
 
bool QAbstractFileEngine::remove()
{
    return false;
}
 
bool QAbstractFileEngine::copy(const QString &newName)
{
    Q_UNUSED(newName);
    return false;
}
 
bool QAbstractFileEngine::rename(const QString &newName)
{
    Q_UNUSED(newName);
    return false;
}
 
bool QAbstractFileEngine::renameOverwrite(const QString &newName)
{
    Q_UNUSED(newName);
    return false;
}
 
bool QAbstractFileEngine::link(const QString &newName)
{
    Q_UNUSED(newName);
    return false;
}
 
bool QAbstractFileEngine::mkdir(const QString &dirName, bool createParentDirectories,
                                std::optional<QFile::Permissions> permissions) const
{
    Q_UNUSED(dirName);
    Q_UNUSED(createParentDirectories);
    Q_UNUSED(permissions);
    return false;
}
 
bool QAbstractFileEngine::rmdir(const QString &dirName, bool recurseParentDirectories) const
{
    Q_UNUSED(dirName);
    Q_UNUSED(recurseParentDirectories);
    return false;
}
 
bool QAbstractFileEngine::setSize(qint64 size)
{
    Q_UNUSED(size);
    return false;
}
 
bool QAbstractFileEngine::caseSensitive() const
{
    return false;
}
 
bool QAbstractFileEngine::isRelativePath() const
{
    return false;
}
 
QStringList QAbstractFileEngine::entryList(QDir::Filters filters, const QStringList &filterNames) const
{
    QStringList ret;
    QDirIterator it(fileName(), filterNames, filters);
    while (it.hasNext()) {
        it.next();
        ret << it.fileName();
    }
    return ret;
}
 
QAbstractFileEngine::FileFlags QAbstractFileEngine::fileFlags(FileFlags type) const
{
    Q_UNUSED(type);
    return {};
}
 
bool QAbstractFileEngine::setPermissions(uint perms)
{
    Q_UNUSED(perms);
    return false;
}
 
QByteArray QAbstractFileEngine::id() const
{
    return QByteArray();
}
 
QString QAbstractFileEngine::fileName(FileName file) const
{
    Q_UNUSED(file);
    return QString();
}
 
uint QAbstractFileEngine::ownerId(FileOwner owner) const
{
    Q_UNUSED(owner);
    return 0;
}
 
QString QAbstractFileEngine::owner(FileOwner owner) const
{
    Q_UNUSED(owner);
    return QString();
}
 
 
bool QAbstractFileEngine::setFileTime(const QDateTime &newDate, FileTime time)
{
    Q_UNUSED(newDate);
    Q_UNUSED(time);
    return false;
}
 
QDateTime QAbstractFileEngine::fileTime(FileTime time) const
{
    Q_UNUSED(time);
    return QDateTime();
}
 
void QAbstractFileEngine::setFileName(const QString &file)
{
    Q_UNUSED(file);
}
 
int QAbstractFileEngine::handle() const
{
    return -1;
}
 
bool QAbstractFileEngine::atEnd() const
{
    return const_cast<QAbstractFileEngine *>(this)->extension(AtEndExtension);
}
 
uchar *QAbstractFileEngine::map(qint64 offset, qint64 size, QFile::MemoryMapFlags flags)
{
    MapExtensionOption option;
    option.offset = offset;
    option.size = size;
    option.flags = flags;
    MapExtensionReturn r;
    if (!extension(MapExtension, &option, &r))
        return nullptr;
    return r.address;
}
 
bool QAbstractFileEngine::unmap(uchar *address)
{
    UnMapExtensionOption options;
    options.address = address;
    return extension(UnMapExtension, &options);
}
 
bool QAbstractFileEngine::cloneTo(QAbstractFileEngine *target)
{
    Q_UNUSED(target);
    return false;
}
 
class QAbstractFileEngineIteratorPrivate
{
public:
    QString path;
    QDir::Filters filters;
    QStringList nameFilters;
    QFileInfo fileInfo;
};
 
QAbstractFileEngineIterator::QAbstractFileEngineIterator(QDir::Filters filters,
                                                         const QStringList &nameFilters)
    : d(new QAbstractFileEngineIteratorPrivate)
{
    d->nameFilters = nameFilters;
    d->filters = filters;
}
 
QAbstractFileEngineIterator::~QAbstractFileEngineIterator()
{
}
 
QString QAbstractFileEngineIterator::path() const
{
    return d->path;
}
 
void QAbstractFileEngineIterator::setPath(const QString &path)
{
    d->path = path;
}
 
QStringList QAbstractFileEngineIterator::nameFilters() const
{
    return d->nameFilters;
}
 
QDir::Filters QAbstractFileEngineIterator::filters() const
{
    return d->filters;
}
 
QString QAbstractFileEngineIterator::currentFilePath() const
{
    QString name = currentFileName();
    if (!name.isNull()) {
        QString tmp = path();
        if (!tmp.isEmpty()) {
            if (!tmp.endsWith(u'/'))
                tmp.append(u'/');
            name.prepend(tmp);
        }
    }
    return name;
}
 
QFileInfo QAbstractFileEngineIterator::currentFileInfo() const
{
    QString path = currentFilePath();
    if (d->fileInfo.filePath() != path)
        d->fileInfo.setFile(path);
 
    // return a shallow copy
    return d->fileInfo;
}
 
QVariant QAbstractFileEngineIterator::entryInfo(EntryInfoType type) const
{
    Q_UNUSED(type);
    return QVariant();
}
 
QAbstractFileEngine::Iterator *QAbstractFileEngine::beginEntryList(QDir::Filters filters, const QStringList &filterNames)
{
    Q_UNUSED(filters);
    Q_UNUSED(filterNames);
    return nullptr;
}
 
QAbstractFileEngine::Iterator *QAbstractFileEngine::endEntryList()
{
    return nullptr;
}
 
qint64 QAbstractFileEngine::read(char *data, qint64 maxlen)
{
    Q_UNUSED(data);
    Q_UNUSED(maxlen);
    return -1;
}
 
qint64 QAbstractFileEngine::write(const char *data, qint64 len)
{
    Q_UNUSED(data);
    Q_UNUSED(len);
    return -1;
}
 
qint64 QAbstractFileEngine::readLine(char *data, qint64 maxlen)
{
    qint64 readSoFar = 0;
    while (readSoFar < maxlen) {
        char c;
        qint64 readResult = read(&c, 1);
        if (readResult <= 0)
            return (readSoFar > 0) ? readSoFar : -1;
        ++readSoFar;
        *data++ = c;
        if (c == '\n')
            return readSoFar;
    }
    return readSoFar;
}
 
bool QAbstractFileEngine::extension(Extension extension, const ExtensionOption *option, ExtensionReturn *output)
{
    Q_UNUSED(extension);
    Q_UNUSED(option);
    Q_UNUSED(output);
    return false;
}
 
bool QAbstractFileEngine::supportsExtension(Extension extension) const
{
    Q_UNUSED(extension);
    return false;
}
 
QFile::FileError QAbstractFileEngine::error() const
{
    Q_D(const QAbstractFileEngine);
    return d->fileError;
}
 
QString QAbstractFileEngine::errorString() const
{
    Q_D(const QAbstractFileEngine);
    return d->errorString;
}
 
void QAbstractFileEngine::setError(QFile::FileError error, const QString &errorString)
{
    Q_D(QAbstractFileEngine);
    d->fileError = error;
    d->errorString = errorString;
}
 
QT_END_NAMESPACE