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 "qdirlisting.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
 
using namespace Qt::StringLiterals;
 
static QString appendSlashIfNeeded(const QString &path)
{
    if (!path.isEmpty() && !path.endsWith(u'/')
#ifdef Q_OS_ANDROID
        && !path.startsWith("content:/"_L1)
#endif
        )
        return QString{path + u'/'};
    return path;
}
 
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 *>
{
    Q_DISABLE_COPY_MOVE(QAbstractFileEngineHandlerList)
public:
    QAbstractFileEngineHandlerList() = default;
 
    ~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.
*/
std::unique_ptr<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 (auto engine = handler->create(path))
                return engine;
        }
    }
 
    return nullptr;
}
 
std::unique_ptr<QAbstractFileEngine> QAbstractFileEngine::create(const QString &fileName)
{
    QFileSystemEntry entry(fileName);
    QFileSystemMetaData metaData;
    auto engine = QFileSystemEngine::createLegacyEngine(entry, metaData);
 
#ifndef QT_NO_FSFILEENGINE
    if (!engine) // fall back to regular file engine
        engine = std::make_unique<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;
#ifdef QT_BOOTSTRAPPED
    Q_UNUSED(filters);
    Q_UNUSED(filterNames);
    Q_UNREACHABLE_RETURN(ret);
#else
    for (const auto &dirEntry : QDirListing(fileName(), filterNames, filters))
        ret.emplace_back(dirEntry.fileName());
    return ret;
#endif
}
 
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, QFile::FileTime time)
{
    Q_UNUSED(newDate);
    Q_UNUSED(time);
    return false;
}
 
QDateTime QAbstractFileEngine::fileTime(QFile::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)
{
    const MapExtensionOption option(offset, size, flags);
    MapExtensionReturn r;
    if (!extension(MapExtension, &option, &r))
        return nullptr;
    return r.address;
}
 
bool QAbstractFileEngine::unmap(uchar *address)
{
    const UnMapExtensionOption options(address);
    return extension(UnMapExtension, &options);
}
 
bool QAbstractFileEngine::cloneTo(QAbstractFileEngine *target)
{
    Q_UNUSED(target);
    return false;
}
 
QAbstractFileEngineIterator::QAbstractFileEngineIterator(const QString &path, QDir::Filters filters,
                                                         const QStringList &nameFilters)
    : m_filters(filters),
      m_nameFilters(nameFilters),
      m_path(appendSlashIfNeeded(path))
{
}
 
QAbstractFileEngineIterator::~QAbstractFileEngineIterator()
{
}
 
QString QAbstractFileEngineIterator::path() const
{
    return m_path;
}
 
QStringList QAbstractFileEngineIterator::nameFilters() const
{
    return m_nameFilters;
}
 
QDir::Filters QAbstractFileEngineIterator::filters() const
{
    return m_filters;
}
 
QString QAbstractFileEngineIterator::currentFilePath() const
{
    QString name = currentFileName();
    if (name.isNull())
        return name;
 
    return path() + name;
}
 
QFileInfo QAbstractFileEngineIterator::currentFileInfo() const
{
    QString path = currentFilePath();
    if (m_fileInfo.filePath() != path)
        m_fileInfo.setFile(path);
 
    // return a shallow copy
    return m_fileInfo;
}
 
QAbstractFileEngine::IteratorUniquePtr
QAbstractFileEngine::beginEntryList(const QString &path, QDir::Filters filters,
                                    const QStringList &filterNames)
{
    Q_UNUSED(path);
    Q_UNUSED(filters);
    Q_UNUSED(filterNames);
    return {};
}
 
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