qdir.cpp

Go to the documentation of this file.

// Copyright (C) 2016 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 "qplatformdefs.h"
#include "qdir.h"
#include "qdir_p.h"
#include "qabstractfileengine_p.h"
#include "qfsfileengine_p.h"
#ifndef QT_NO_DEBUG_STREAM
#include "qdebug.h"
#endif
#include "qdiriterator.h"
#include "qdatetime.h"
#include "qstring.h"
#if QT_CONFIG(regularexpression)
#  include <qregularexpression.h>
#endif
#include "qvarlengtharray.h"
#include "qfilesystementry_p.h"
#include "qfilesystemmetadata_p.h"
#include "qfilesystemengine_p.h"
#include <qstringbuilder.h>
 
#ifndef QT_BOOTSTRAPPED
#  include <qcollator.h>
#  include "qreadwritelock.h"
#  include "qmutex.h"
#endif
 
#include <algorithm>
#include <memory>
#include <stdlib.h>
 
QT_BEGIN_NAMESPACE
 
using namespace Qt::StringLiterals;
 
#if defined(Q_OS_WIN)
static QString driveSpec(const QString &path)
{
    if (path.size() < 2)
        return QString();
    char c = path.at(0).toLatin1();
    if ((c < 'a' || c > 'z') && (c < 'A' || c > 'Z'))
        return QString();
    if (path.at(1).toLatin1() != ':')
        return QString();
    return path.mid(0, 2);
}
#endif
 
enum {
#if defined(Q_OS_WIN)
    OSSupportsUncPaths = true
#else
    OSSupportsUncPaths = false
#endif
};
 
// Return the length of the root part of an absolute path, for use by cleanPath(), cd().
static qsizetype rootLength(QStringView name, bool allowUncPaths)
{
    const qsizetype len = name.size();
    // starts with double slash
    if (allowUncPaths && name.startsWith("//"_L1)) {
        // Server name '//server/path' is part of the prefix.
        const qsizetype nextSlash = name.indexOf(u'/', 2);
        return nextSlash >= 0 ? nextSlash + 1 : len;
    }
#if defined(Q_OS_WIN)
    if (len >= 2 && name.at(1) == u':') {
        // Handle a possible drive letter
        return len > 2 && name.at(2) == u'/' ? 3 : 2;
    }
#endif
    if (name.at(0) == u'/')
        return 1;
    return 0;
}
 
//************* QDirPrivate
QDirPrivate::QDirPrivate(const QString &path, const QStringList &nameFilters_,
                         QDir::SortFlags sort_, QDir::Filters filters_)
    : QSharedData(), nameFilters(nameFilters_), sort(sort_), filters(filters_)
{
    setPath(path.isEmpty() ? QString::fromLatin1(".") : path);
 
    auto isEmpty = [](const auto &e) { return e.isEmpty(); };
    const bool empty = std::all_of(nameFilters.cbegin(), nameFilters.cend(), isEmpty);
    if (empty)
        nameFilters = QStringList(QString::fromLatin1("*"));
}
 
QDirPrivate::QDirPrivate(const QDirPrivate &copy)
    : QSharedData(copy),
      // mutex is not copied
      nameFilters(copy.nameFilters),
      sort(copy.sort),
      filters(copy.filters),
      // fileEngine is not copied
      dirEntry(copy.dirEntry)
{
    QMutexLocker locker(&copy.fileCache.mutex);
    fileCache.fileListsInitialized = copy.fileCache.fileListsInitialized.load();
    fileCache.files = copy.fileCache.files;
    fileCache.fileInfos = copy.fileCache.fileInfos;
    fileCache.absoluteDirEntry = copy.fileCache.absoluteDirEntry;
    fileCache.metaData = copy.fileCache.metaData;
}
 
bool QDirPrivate::exists() const
{
    if (!fileEngine) {
        QMutexLocker locker(&fileCache.mutex);
        QFileSystemEngine::fillMetaData(
                dirEntry, fileCache.metaData,
                QFileSystemMetaData::ExistsAttribute
                        | QFileSystemMetaData::DirectoryType); // always stat
        return fileCache.metaData.exists() && fileCache.metaData.isDirectory();
    }
    const QAbstractFileEngine::FileFlags info =
        fileEngine->fileFlags(QAbstractFileEngine::DirectoryType
                                       | QAbstractFileEngine::ExistsFlag
                                       | QAbstractFileEngine::Refresh);
    if (!(info & QAbstractFileEngine::DirectoryType))
        return false;
    return info.testAnyFlag(QAbstractFileEngine::ExistsFlag);
}
 
// static
inline QChar QDirPrivate::getFilterSepChar(const QString &nameFilter)
{
    QChar sep(u';');
    qsizetype i = nameFilter.indexOf(sep, 0);
    if (i == -1 && nameFilter.indexOf(u' ', 0) != -1)
        sep = QChar(u' ');
    return sep;
}
 
// static
inline QStringList QDirPrivate::splitFilters(const QString &nameFilter, QChar sep)
{
    if (sep.isNull())
        sep = getFilterSepChar(nameFilter);
    QStringList ret;
    for (auto e : qTokenize(nameFilter, sep))
        ret.append(e.trimmed().toString());
    return ret;
}
 
inline void QDirPrivate::setPath(const QString &path)
{
    QString p = QDir::fromNativeSeparators(path);
    if (p.endsWith(u'/')
            && p.size() > 1
#if defined(Q_OS_WIN)
        && (!(p.length() == 3 && p.at(1).unicode() == ':' && p.at(0).isLetter()))
#endif
    ) {
            p.truncate(p.size() - 1);
    }
    dirEntry = QFileSystemEntry(p, QFileSystemEntry::FromInternalPath());
    clearCache(IncludingMetaData);
    fileCache.absoluteDirEntry = QFileSystemEntry();
}
 
inline QString QDirPrivate::resolveAbsoluteEntry() const
{
    QMutexLocker locker(&fileCache.mutex);
    if (!fileCache.absoluteDirEntry.isEmpty())
        return fileCache.absoluteDirEntry.filePath();
 
    if (dirEntry.isEmpty())
        return dirEntry.filePath();
 
    QString absoluteName;
    if (!fileEngine) {
        if (!dirEntry.isRelative() && dirEntry.isClean()) {
            fileCache.absoluteDirEntry = dirEntry;
            return dirEntry.filePath();
        }
 
        absoluteName = QFileSystemEngine::absoluteName(dirEntry).filePath();
    } else {
        absoluteName = fileEngine->fileName(QAbstractFileEngine::AbsoluteName);
    }
    auto absoluteFileSystemEntry =
            QFileSystemEntry(QDir::cleanPath(absoluteName), QFileSystemEntry::FromInternalPath());
    fileCache.absoluteDirEntry = absoluteFileSystemEntry;
    return absoluteFileSystemEntry.filePath();
}
 
/* For sorting */
struct QDirSortItem
{
    QDirSortItem() = default;
    QDirSortItem(const QFileInfo &fi, QDir::SortFlags sort)
        : item(fi)
    {
        // A dir e.g. "dirA.bar" doesn't have actually have an extension/suffix, when
        // sorting by type such "suffix" should be ignored but that would complicate
        // the code and uses can change the behavior by setting DirsFirst/DirsLast
        if (sort.testAnyFlag(QDir::Type))
            suffix_cache = item.suffix();
    }
 
    mutable QString filename_cache;
    QString suffix_cache;
    QFileInfo item;
};
 
class QDirSortItemComparator
{
    QDir::SortFlags qt_cmp_si_sort_flags;
 
#ifndef QT_BOOTSTRAPPED
    QCollator *collator = nullptr;
#endif
public:
#ifndef QT_BOOTSTRAPPED
    QDirSortItemComparator(QDir::SortFlags flags, QCollator *coll = nullptr)
        : qt_cmp_si_sort_flags(flags), collator(coll)
    {
        Q_ASSERT(!qt_cmp_si_sort_flags.testAnyFlag(QDir::LocaleAware) || collator);
 
        if (collator && qt_cmp_si_sort_flags.testAnyFlag(QDir::IgnoreCase))
            collator->setCaseSensitivity(Qt::CaseInsensitive);
    }
#else
    QDirSortItemComparator(QDir::SortFlags flags)
        : qt_cmp_si_sort_flags(flags)
    {
    }
#endif
    bool operator()(const QDirSortItem &, const QDirSortItem &) const;
 
    int compareStrings(const QString &a, const QString &b, Qt::CaseSensitivity cs) const
    {
#ifndef QT_BOOTSTRAPPED
        if (collator)
            return collator->compare(a, b);
#endif
        return a.compare(b, cs);
    }
};
 
bool QDirSortItemComparator::operator()(const QDirSortItem &n1, const QDirSortItem &n2) const
{
    const QDirSortItem* f1 = &n1;
    const QDirSortItem* f2 = &n2;
 
    if ((qt_cmp_si_sort_flags & QDir::DirsFirst) && (f1->item.isDir() != f2->item.isDir()))
        return f1->item.isDir();
    if ((qt_cmp_si_sort_flags & QDir::DirsLast) && (f1->item.isDir() != f2->item.isDir()))
        return !f1->item.isDir();
 
    const bool ic = qt_cmp_si_sort_flags.testAnyFlag(QDir::IgnoreCase);
    const auto qtcase = ic ? Qt::CaseInsensitive : Qt::CaseSensitive;
 
    qint64 r = 0;
    int sortBy = ((qt_cmp_si_sort_flags & QDir::SortByMask)
                 | (qt_cmp_si_sort_flags & QDir::Type)).toInt();
 
    switch (sortBy) {
      case QDir::Time: {
        const QDateTime firstModified = f1->item.lastModified(QTimeZone::UTC);
        const QDateTime secondModified = f2->item.lastModified(QTimeZone::UTC);
        r = firstModified.msecsTo(secondModified);
        break;
      }
      case QDir::Size:
          r = f2->item.size() - f1->item.size();
        break;
    case QDir::Type:
        r = compareStrings(f1->suffix_cache, f2->suffix_cache, qtcase);
        break;
      default:
        ;
    }
 
    if (r == 0 && sortBy != QDir::Unsorted) {
        // Still not sorted - sort by name
 
        if (f1->filename_cache.isNull())
            f1->filename_cache = f1->item.fileName();
        if (f2->filename_cache.isNull())
            f2->filename_cache = f2->item.fileName();
 
        r = compareStrings(f1->filename_cache, f2->filename_cache, qtcase);
    }
    if (qt_cmp_si_sort_flags & QDir::Reversed)
        return r > 0;
    return r < 0;
}
 
inline void QDirPrivate::sortFileList(QDir::SortFlags sort, const QFileInfoList &l,
                                      QStringList *names, QFileInfoList *infos)
{
    Q_ASSERT(names || infos);
    Q_ASSERT(!infos || infos->isEmpty());
    Q_ASSERT(!names || names->isEmpty());
 
    const qsizetype n = l.size();
    if (n == 0)
        return;
 
    if (n == 1 || (sort & QDir::SortByMask) == QDir::Unsorted) {
        if (infos)
            *infos = l;
 
        if (names) {
            for (const QFileInfo &fi : l)
                names->append(fi.fileName());
        }
    } else {
        QScopedArrayPointer<QDirSortItem> si(new QDirSortItem[n]);
        for (qsizetype i = 0; i < n; ++i)
            si[i] = QDirSortItem{l.at(i), sort};
 
#ifndef QT_BOOTSTRAPPED
    if (sort.testAnyFlag(QDir::LocaleAware)) {
            QCollator coll;
            std::sort(si.data(), si.data() + n, QDirSortItemComparator(sort, &coll));
        } else {
            std::sort(si.data(), si.data() + n, QDirSortItemComparator(sort));
        }
#else
        std::sort(si.data(), si.data() + n, QDirSortItemComparator(sort));
#endif // QT_BOOTSTRAPPED
 
        // put them back in the list(s)
        for (qsizetype i = 0; i < n; ++i) {
            auto &fileInfo = si[i].item;
            if (infos)
                infos->append(fileInfo);
            if (names) {
                const bool cached = !si[i].filename_cache.isNull();
                names->append(cached ? si[i].filename_cache : fileInfo.fileName());
            }
        }
    }
}
 
inline void QDirPrivate::initFileLists(const QDir &dir) const
{
    QMutexLocker locker(&fileCache.mutex);
    if (!fileCache.fileListsInitialized) {
        QFileInfoList l;
        QDirIterator it(dir);
        while (it.hasNext())
            l.append(it.nextFileInfo());
 
        sortFileList(sort, l, &fileCache.files, &fileCache.fileInfos);
        fileCache.fileListsInitialized = true;
    }
}
 
inline void QDirPrivate::clearCache(MetaDataClearing mode)
{
    QMutexLocker locker(&fileCache.mutex);
    if (mode == IncludingMetaData)
        fileCache.metaData.clear();
    fileCache.fileListsInitialized = false;
    fileCache.files.clear();
    fileCache.fileInfos.clear();
    fileEngine.reset(
            QFileSystemEngine::resolveEntryAndCreateLegacyEngine(dirEntry, fileCache.metaData));
}
 
QDir::QDir(QDirPrivate &p) : d_ptr(&p)
{
}
 
QDir::QDir(const QString &path) : d_ptr(new QDirPrivate(path))
{
}
 
QDir::QDir(const QString &path, const QString &nameFilter,
           SortFlags sort, Filters filters)
    : d_ptr(new QDirPrivate(path, QDir::nameFiltersFromString(nameFilter), sort, filters))
{
}
 
QDir::QDir(const QDir &dir)
    : d_ptr(dir.d_ptr)
{
}
 
QDir::~QDir()
{
}
 
void QDir::setPath(const QString &path)
{
    d_ptr->setPath(path);
}
 
QString QDir::path() const
{
    Q_D(const QDir);
    return d->dirEntry.filePath();
}
 
QString QDir::absolutePath() const
{
    Q_D(const QDir);
    if (!d->fileEngine)
        return d->resolveAbsoluteEntry();
 
    return d->fileEngine->fileName(QAbstractFileEngine::AbsoluteName);
}
 
QString QDir::canonicalPath() const
{
    Q_D(const QDir);
    if (!d->fileEngine) {
        QMutexLocker locker(&d->fileCache.mutex);
        QFileSystemEntry answer =
                QFileSystemEngine::canonicalName(d->dirEntry, d->fileCache.metaData);
        return answer.filePath();
    }
    return d->fileEngine->fileName(QAbstractFileEngine::CanonicalName);
}
 
QString QDir::dirName() const
{
    Q_D(const QDir);
    if (!d_ptr->fileEngine)
        return d->dirEntry.fileName();
    return d->fileEngine->fileName(QAbstractFileEngine::BaseName);
}
 
 
#ifdef Q_OS_WIN
static qsizetype drivePrefixLength(QStringView path)
{
    // Used to extract path's drive for use as prefix for an "absolute except for drive" path
    const qsizetype size = path.size();
    qsizetype drive = 2; // length of drive prefix
    if (size > 1 && path.at(1).unicode() == ':') {
        if (Q_UNLIKELY(!path.at(0).isLetter()))
            return 0;
    } else if (path.startsWith("//"_L1)) {
        // UNC path; use its //server/share part as "drive" - it's as sane a
        // thing as we can do.
        for (int i = 0 ; i < 2 ; ++i) { // Scan two "path fragments":
            while (drive < size && path.at(drive).unicode() == '/')
                drive++;
            if (drive >= size) {
                qWarning("Base directory starts with neither a drive nor a UNC share: %s",
                         qUtf8Printable(QDir::toNativeSeparators(path.toString())));
                return 0;
            }
            while (drive < size && path.at(drive).unicode() != '/')
                drive++;
        }
    } else {
        return 0;
    }
    return drive;
}
#endif // Q_OS_WIN
 
static bool treatAsAbsolute(const QString &path)
{
    // ### Qt 6: be consistent about absolute paths
 
    // QFileInfo will use the right FS-engine for virtual file-systems
    // (e.g. resource paths).  Unfortunately, for real file-systems, it relies
    // on QFileSystemEntry's isRelative(), which is flawed on MS-Win, ignoring
    // its (correct) isAbsolute().  So only use that isAbsolute() unless there's
    // a colon in the path.
    // FIXME: relies on virtual file-systems having colons in their prefixes.
    // The case of an MS-absolute C:/... path happens to work either way.
    return (path.contains(u':') && QFileInfo(path).isAbsolute())
        || QFileSystemEntry(path).isAbsolute();
}
 
QString QDir::filePath(const QString &fileName) const
{
    if (treatAsAbsolute(fileName))
        return fileName;
 
    Q_D(const QDir);
    QString ret = d->dirEntry.filePath();
    if (fileName.isEmpty())
        return ret;
 
#ifdef Q_OS_WIN
    if (fileName.startsWith(u'/') || fileName.startsWith(u'\\')) {
        // Handle the "absolute except for drive" case (i.e. \blah not c:\blah):
        const qsizetype drive = drivePrefixLength(ret);
        return drive > 0 ? QStringView{ret}.left(drive) % fileName : fileName;
    }
#endif // Q_OS_WIN
 
    if (ret.isEmpty() || ret.endsWith(u'/'))
        return ret % fileName;
    return ret % u'/' % fileName;
}
 
QString QDir::absoluteFilePath(const QString &fileName) const
{
    if (treatAsAbsolute(fileName))
        return fileName;
 
    Q_D(const QDir);
    QString absoluteDirPath = d->resolveAbsoluteEntry();
    if (fileName.isEmpty())
        return absoluteDirPath;
#ifdef Q_OS_WIN
    // Handle the "absolute except for drive" case (i.e. \blah not c:\blah):
    if (fileName.startsWith(u'/') || fileName.startsWith(u'\\')) {
        // Combine absoluteDirPath's drive with fileName
        const qsizetype drive = drivePrefixLength(absoluteDirPath);
        if (Q_LIKELY(drive))
            return QStringView{absoluteDirPath}.left(drive) % fileName;
 
        qWarning("Base directory's drive is not a letter: %s",
                 qUtf8Printable(QDir::toNativeSeparators(absoluteDirPath)));
        return QString();
    }
#endif // Q_OS_WIN
    if (!absoluteDirPath.endsWith(u'/'))
        return absoluteDirPath % u'/' % fileName;
    return absoluteDirPath % fileName;
}
 
QString QDir::relativeFilePath(const QString &fileName) const
{
    QString dir = cleanPath(absolutePath());
    QString file = cleanPath(fileName);
 
    if (isRelativePath(file) || isRelativePath(dir))
        return file;
 
#ifdef Q_OS_WIN
    QString dirDrive = driveSpec(dir);
    QString fileDrive = driveSpec(file);
 
    bool fileDriveMissing = false;
    if (fileDrive.isEmpty()) {
        fileDrive = dirDrive;
        fileDriveMissing = true;
    }
 
    if (fileDrive.toLower() != dirDrive.toLower()
            || (file.startsWith("//"_L1)
                && !dir.startsWith("//"_L1))) {
        return file;
    }
 
    dir.remove(0, dirDrive.size());
    if (!fileDriveMissing)
        file.remove(0, fileDrive.size());
#endif
 
    QString result;
    const auto dirElts = dir.tokenize(u'/', Qt::SkipEmptyParts);
    const auto fileElts = file.tokenize(u'/', Qt::SkipEmptyParts);
 
    const auto dend = dirElts.end();
    const auto fend = fileElts.end();
    auto dit = dirElts.begin();
    auto fit = fileElts.begin();
 
    const auto eq = [](QStringView lhs, QStringView rhs) {
        return
#if defined(Q_OS_WIN)
           lhs.compare(rhs, Qt::CaseInsensitive) == 0;
#else
           lhs == rhs;
#endif
    };
 
    // std::ranges::mismatch
    while (dit != dend && fit != fend && eq(*dit, *fit)) {
        ++dit;
        ++fit;
    }
 
    while (dit != dend) {
        result += "../"_L1;
        ++dit;
    }
 
    if (fit != fend) {
        while (fit != fend) {
            result += *fit++;
            result += u'/';
        }
        result.chop(1);
    }
 
    if (result.isEmpty())
        result = "."_L1;
    return result;
}
 
QString QDir::toNativeSeparators(const QString &pathName)
{
#if defined(Q_OS_WIN)
    qsizetype i = pathName.indexOf(u'/');
    if (i != -1) {
        QString n(pathName);
 
        QChar * const data = n.data();
        data[i++] = u'\\';
 
        for (; i < n.length(); ++i) {
            if (data[i] == u'/')
                data[i] = u'\\';
        }
 
        return n;
    }
#endif
    return pathName;
}
 
QString QDir::fromNativeSeparators(const QString &pathName)
{
#if defined(Q_OS_WIN)
    return QFileSystemEntry::removeUncOrLongPathPrefix(pathName).replace(u'\\', u'/');
#else
    return pathName;
#endif
}
 
static QString qt_cleanPath(const QString &path, bool *ok = nullptr);
 
bool QDir::cd(const QString &dirName)
{
    // Don't detach just yet.
    const QDirPrivate * const d = d_ptr.constData();
 
    if (dirName.isEmpty() || dirName == u'.')
        return true;
    QString newPath;
    if (isAbsolutePath(dirName)) {
        newPath = qt_cleanPath(dirName);
    } else {
        newPath = d->dirEntry.filePath();
        if (!newPath.endsWith(u'/'))
            newPath += u'/';
        newPath += dirName;
        if (dirName.indexOf(u'/') >= 0
            || dirName == ".."_L1
            || d->dirEntry.filePath() == u'.') {
            bool ok;
            newPath = qt_cleanPath(newPath, &ok);
            if (!ok)
                return false;
            /*
              If newPath starts with .., we convert it to absolute to
              avoid infinite looping on
 
                  QDir dir(".");
                  while (dir.cdUp())
                      ;
            */
            if (newPath.startsWith(".."_L1)) {
                newPath = QFileInfo(newPath).absoluteFilePath();
            }
        }
    }
 
    std::unique_ptr<QDirPrivate> dir(new QDirPrivate(*d_ptr.constData()));
    dir->setPath(newPath);
    if (!dir->exists())
        return false;
 
    d_ptr = dir.release();
    return true;
}
 
bool QDir::cdUp()
{
    return cd(QString::fromLatin1(".."));
}
 
QStringList QDir::nameFilters() const
{
    Q_D(const QDir);
    return d->nameFilters;
}
 
void QDir::setNameFilters(const QStringList &nameFilters)
{
    Q_D(QDir);
    d->clearCache(QDirPrivate::KeepMetaData);
    d->nameFilters = nameFilters;
}
 
#ifndef QT_BOOTSTRAPPED
 
namespace {
struct DirSearchPaths {
    mutable QReadWriteLock mutex;
    QHash<QString, QStringList> paths;
};
}
 
Q_GLOBAL_STATIC(DirSearchPaths, dirSearchPaths)
 
 
void QDir::setSearchPaths(const QString &prefix, const QStringList &searchPaths)
{
    if (prefix.size() < 2) {
        qWarning("QDir::setSearchPaths: Prefix must be longer than 1 character");
        return;
    }
 
    for (QChar ch : prefix) {
        if (!ch.isLetterOrNumber()) {
            qWarning("QDir::setSearchPaths: Prefix can only contain letters or numbers");
            return;
        }
    }
 
    DirSearchPaths &conf = *dirSearchPaths;
    const QWriteLocker lock(&conf.mutex);
    if (searchPaths.isEmpty()) {
        conf.paths.remove(prefix);
    } else {
        conf.paths.insert(prefix, searchPaths);
    }
}
 
void QDir::addSearchPath(const QString &prefix, const QString &path)
{
    if (path.isEmpty())
        return;
 
    DirSearchPaths &conf = *dirSearchPaths;
    const QWriteLocker lock(&conf.mutex);
    conf.paths[prefix] += path;
}
 
QStringList QDir::searchPaths(const QString &prefix)
{
    if (!dirSearchPaths.exists())
        return QStringList();
 
    const DirSearchPaths &conf = *dirSearchPaths;
    const QReadLocker lock(&conf.mutex);
    return conf.paths.value(prefix);
}
 
#endif // QT_BOOTSTRAPPED
 
QDir::Filters QDir::filter() const
{
    Q_D(const QDir);
    return d->filters;
}
 
void QDir::setFilter(Filters filters)
{
    Q_D(QDir);
    d->clearCache(QDirPrivate::KeepMetaData);
    d->filters = filters;
}
 
QDir::SortFlags QDir::sorting() const
{
    Q_D(const QDir);
    return d->sort;
}
 
void QDir::setSorting(SortFlags sort)
{
    Q_D(QDir);
    d->clearCache(QDirPrivate::KeepMetaData);
    d->sort = sort;
}
 
qsizetype QDir::count(QT6_IMPL_NEW_OVERLOAD) const
{
    Q_D(const QDir);
    d->initFileLists(*this);
    return d->fileCache.files.size();
}
 
QString QDir::operator[](qsizetype pos) const
{
    Q_D(const QDir);
    d->initFileLists(*this);
    return d->fileCache.files[pos];
}
 
QStringList QDir::entryList(Filters filters, SortFlags sort) const
{
    Q_D(const QDir);
    return entryList(d->nameFilters, filters, sort);
}
 
 
QFileInfoList QDir::entryInfoList(Filters filters, SortFlags sort) const
{
    Q_D(const QDir);
    return entryInfoList(d->nameFilters, filters, sort);
}
 
QStringList QDir::entryList(const QStringList &nameFilters, Filters filters,
                            SortFlags sort) const
{
    Q_D(const QDir);
 
    if (filters == NoFilter)
        filters = d->filters;
    if (sort == NoSort)
        sort = d->sort;
 
    const bool needsSorting = (sort & QDir::SortByMask) != QDir::Unsorted;
 
    if (filters == d->filters && sort == d->sort && nameFilters == d->nameFilters) {
        // Don't fill a QFileInfo cache if we just need names
        if (needsSorting || d->fileCache.fileListsInitialized) {
            d->initFileLists(*this);
            return d->fileCache.files;
        }
    }
 
    QDirIterator it(d->dirEntry.filePath(), nameFilters, filters);
    QStringList ret;
    if (needsSorting) {
        QFileInfoList l;
        while (it.hasNext())
            l.append(it.nextFileInfo());
        d->sortFileList(sort, l, &ret, nullptr);
    } else {
        while (it.hasNext()) {
            it.next();
            ret.append(it.fileName());
        }
    }
    return ret;
}
 
QFileInfoList QDir::entryInfoList(const QStringList &nameFilters, Filters filters,
                                  SortFlags sort) const
{
    Q_D(const QDir);
 
    if (filters == NoFilter)
        filters = d->filters;
    if (sort == NoSort)
        sort = d->sort;
 
    if (filters == d->filters && sort == d->sort && nameFilters == d->nameFilters) {
        d->initFileLists(*this);
        return d->fileCache.fileInfos;
    }
 
    QFileInfoList l;
    QDirIterator it(d->dirEntry.filePath(), nameFilters, filters);
    while (it.hasNext())
        l.append(it.nextFileInfo());
    QFileInfoList ret;
    d->sortFileList(sort, l, nullptr, &ret);
    return ret;
}
 
bool QDir::mkdir(const QString &dirName, QFile::Permissions permissions) const
{
    Q_D(const QDir);
 
    if (dirName.isEmpty()) {
        qWarning("QDir::mkdir: Empty or null file name");
        return false;
    }
 
    QString fn = filePath(dirName);
    if (!d->fileEngine)
        return QFileSystemEngine::createDirectory(QFileSystemEntry(fn), false, permissions);
    return d->fileEngine->mkdir(fn, false, permissions);
}
 
bool QDir::mkdir(const QString &dirName) const
{
    Q_D(const QDir);
 
    if (dirName.isEmpty()) {
        qWarning("QDir::mkdir: Empty or null file name");
        return false;
    }
 
    QString fn = filePath(dirName);
    if (!d->fileEngine)
        return QFileSystemEngine::createDirectory(QFileSystemEntry(fn), false);
    return d->fileEngine->mkdir(fn, false);
}
 
bool QDir::rmdir(const QString &dirName) const
{
    Q_D(const QDir);
 
    if (dirName.isEmpty()) {
        qWarning("QDir::rmdir: Empty or null file name");
        return false;
    }
 
    QString fn = filePath(dirName);
    if (!d->fileEngine)
        return QFileSystemEngine::removeDirectory(QFileSystemEntry(fn), false);
 
    return d->fileEngine->rmdir(fn, false);
}
 
bool QDir::mkpath(const QString &dirPath) const
{
    Q_D(const QDir);
 
    if (dirPath.isEmpty()) {
        qWarning("QDir::mkpath: Empty or null file name");
        return false;
    }
 
    QString fn = filePath(dirPath);
    if (!d->fileEngine)
        return QFileSystemEngine::createDirectory(QFileSystemEntry(fn), true);
    return d->fileEngine->mkdir(fn, true);
}
 
bool QDir::rmpath(const QString &dirPath) const
{
    Q_D(const QDir);
 
    if (dirPath.isEmpty()) {
        qWarning("QDir::rmpath: Empty or null file name");
        return false;
    }
 
    QString fn = filePath(dirPath);
    if (!d->fileEngine)
        return QFileSystemEngine::removeDirectory(QFileSystemEntry(fn), true);
    return d->fileEngine->rmdir(fn, true);
}
 
bool QDir::removeRecursively()
{
    if (!d_ptr->exists())
        return true;
 
    bool success = true;
    const QString dirPath = path();
    // not empty -- we must empty it first
    QDirIterator di(dirPath, QDir::AllEntries | QDir::Hidden | QDir::System | QDir::NoDotAndDotDot);
    while (di.hasNext()) {
        const QFileInfo fi = di.nextFileInfo();
        const QString &filePath = di.filePath();
        bool ok;
        if (fi.isDir() && !fi.isSymLink()) {
            ok = QDir(filePath).removeRecursively(); // recursive
        } else {
            ok = QFile::remove(filePath);
            if (!ok) { // Read-only files prevent directory deletion on Windows, retry with Write permission.
                const QFile::Permissions permissions = QFile::permissions(filePath);
                if (!(permissions & QFile::WriteUser))
                    ok = QFile::setPermissions(filePath, permissions | QFile::WriteUser)
                        && QFile::remove(filePath);
            }
        }
        if (!ok)
            success = false;
    }
 
    if (success)
        success = rmdir(absolutePath());
 
    return success;
}
 
bool QDir::isReadable() const
{
    Q_D(const QDir);
 
    if (!d->fileEngine) {
        QMutexLocker locker(&d->fileCache.mutex);
        if (!d->fileCache.metaData.hasFlags(QFileSystemMetaData::UserReadPermission)) {
            QFileSystemEngine::fillMetaData(d->dirEntry, d->fileCache.metaData,
                                            QFileSystemMetaData::UserReadPermission);
        }
        return d->fileCache.metaData.permissions().testAnyFlag(QFile::ReadUser);
    }
 
    const QAbstractFileEngine::FileFlags info =
        d->fileEngine->fileFlags(QAbstractFileEngine::DirectoryType
                                       | QAbstractFileEngine::PermsMask);
    if (!(info & QAbstractFileEngine::DirectoryType))
        return false;
    return info.testAnyFlag(QAbstractFileEngine::ReadUserPerm);
}
 
bool QDir::exists() const
{
    return d_ptr->exists();
}
 
bool QDir::isRoot() const
{
    if (!d_ptr->fileEngine)
        return d_ptr->dirEntry.isRoot();
    return d_ptr->fileEngine->fileFlags(QAbstractFileEngine::FlagsMask).testAnyFlag(QAbstractFileEngine::RootFlag);
}
 
bool QDir::isRelative() const
{
    if (!d_ptr->fileEngine)
        return d_ptr->dirEntry.isRelative();
    return d_ptr->fileEngine->isRelativePath();
}
 
 
bool QDir::makeAbsolute()
{
    Q_D(const QDir);
    std::unique_ptr<QDirPrivate> dir;
    if (!!d->fileEngine) {
        QString absolutePath = d->fileEngine->fileName(QAbstractFileEngine::AbsoluteName);
        if (QDir::isRelativePath(absolutePath))
            return false;
 
        dir.reset(new QDirPrivate(*d_ptr.constData()));
        dir->setPath(absolutePath);
    } else { // native FS
        QString absoluteFilePath = d->resolveAbsoluteEntry();
        dir.reset(new QDirPrivate(*d_ptr.constData()));
        dir->setPath(absoluteFilePath);
    }
    d_ptr = dir.release(); // actually detach
    return true;
}
 
bool QDir::operator==(const QDir &dir) const
{
    Q_D(const QDir);
    const QDirPrivate *other = dir.d_ptr.constData();
 
    if (d == other)
        return true;
    Qt::CaseSensitivity sensitive;
    if (!d->fileEngine || !other->fileEngine) {
        if (d->fileEngine.get() != other->fileEngine.get()) // one is native, the other is a custom file-engine
            return false;
 
        sensitive = QFileSystemEngine::isCaseSensitive() ? Qt::CaseSensitive : Qt::CaseInsensitive;
    } else {
        if (d->fileEngine->caseSensitive() != other->fileEngine->caseSensitive())
            return false;
        sensitive = d->fileEngine->caseSensitive() ? Qt::CaseSensitive : Qt::CaseInsensitive;
    }
 
    if (d->filters == other->filters
       && d->sort == other->sort
       && d->nameFilters == other->nameFilters) {
 
        // Assume directories are the same if path is the same
        if (d->dirEntry.filePath() == other->dirEntry.filePath())
            return true;
 
        if (exists()) {
            if (!dir.exists())
                return false; //can't be equal if only one exists
            // Both exist, fallback to expensive canonical path computation
            return canonicalPath().compare(dir.canonicalPath(), sensitive) == 0;
        } else {
            if (dir.exists())
                return false; //can't be equal if only one exists
            // Neither exists, compare absolute paths rather than canonical (which would be empty strings)
            QString thisFilePath = d->resolveAbsoluteEntry();
            QString otherFilePath = other->resolveAbsoluteEntry();
            return thisFilePath.compare(otherFilePath, sensitive) == 0;
        }
    }
    return false;
}
 
QDir &QDir::operator=(const QDir &dir)
{
    d_ptr = dir.d_ptr;
    return *this;
}
 
bool QDir::remove(const QString &fileName)
{
    if (fileName.isEmpty()) {
        qWarning("QDir::remove: Empty or null file name");
        return false;
    }
    return QFile::remove(filePath(fileName));
}
 
bool QDir::rename(const QString &oldName, const QString &newName)
{
    if (oldName.isEmpty() || newName.isEmpty()) {
        qWarning("QDir::rename: Empty or null file name(s)");
        return false;
    }
 
    QFile file(filePath(oldName));
    if (!file.exists())
        return false;
    return file.rename(filePath(newName));
}
 
bool QDir::exists(const QString &name) const
{
    if (name.isEmpty()) {
        qWarning("QDir::exists: Empty or null file name");
        return false;
    }
    return QFileInfo::exists(filePath(name));
}
 
bool QDir::isEmpty(Filters filters) const
{
    Q_D(const QDir);
    QDirIterator it(d->dirEntry.filePath(), d->nameFilters, filters);
    return !it.hasNext();
}
 
QFileInfoList QDir::drives()
{
#ifdef QT_NO_FSFILEENGINE
    return QFileInfoList();
#else
    return QFSFileEngine::drives();
#endif
}
 
bool QDir::setCurrent(const QString &path)
{
    return QFileSystemEngine::setCurrentPath(QFileSystemEntry(path));
}
 
QString QDir::currentPath()
{
    return QFileSystemEngine::currentPath().filePath();
}
 
QString QDir::homePath()
{
    return QFileSystemEngine::homePath();
}
 
QString QDir::tempPath()
{
    return QFileSystemEngine::tempPath();
}
 
QString QDir::rootPath()
{
    return QFileSystemEngine::rootPath();
}
 
#if QT_CONFIG(regularexpression)
bool QDir::match(const QStringList &filters, const QString &fileName)
{
    for (QStringList::ConstIterator sit = filters.constBegin(); sit != filters.constEnd(); ++sit) {
        // Insensitive exact match
        auto rx = QRegularExpression::fromWildcard(*sit, Qt::CaseInsensitive);
        if (rx.match(fileName).hasMatch())
            return true;
    }
    return false;
}
 
bool QDir::match(const QString &filter, const QString &fileName)
{
    return match(nameFiltersFromString(filter), fileName);
}
#endif // QT_CONFIG(regularexpression)
 
QString qt_normalizePathSegments(const QString &name, QDirPrivate::PathNormalizations flags, bool *ok)
{
    const bool allowUncPaths = flags.testAnyFlag(QDirPrivate::AllowUncPaths);
    const bool isRemote = flags.testAnyFlag(QDirPrivate::RemotePath);
    const qsizetype len = name.size();
 
    if (ok)
        *ok = false;
 
    if (len == 0)
        return name;
 
    qsizetype i = len - 1;
    QVarLengthArray<char16_t> outVector(len);
    qsizetype used = len;
    char16_t *out = outVector.data();
    const char16_t *p = reinterpret_cast<const char16_t *>(name.data());
    const char16_t *prefix = p;
    qsizetype up = 0;
 
    const qsizetype prefixLength = rootLength(name, allowUncPaths);
    p += prefixLength;
    i -= prefixLength;
 
    // replicate trailing slash (i > 0 checks for emptiness of input string p)
    // except for remote paths because there can be /../ or /./ ending
    if (i > 0 && p[i] == '/' && !isRemote) {
        out[--used] = '/';
        --i;
    }
 
    auto isDot = [](const char16_t *p, qsizetype i) {
        return i > 1 && p[i - 1] == '.' && p[i - 2] == '/';
    };
    auto isDotDot = [](const char16_t *p, qsizetype i) {
        return i > 2 && p[i - 1] == '.' && p[i - 2] == '.' && p[i - 3] == '/';
    };
 
    while (i >= 0) {
        // copy trailing slashes for remote urls
        if (p[i] == '/') {
            if (isRemote && !up) {
                if (isDot(p, i)) {
                    i -= 2;
                    continue;
                }
                out[--used] = p[i];
            }
 
            --i;
            continue;
        }
 
        // remove current directory
        if (p[i] == '.' && (i == 0 || p[i-1] == '/')) {
            --i;
            continue;
        }
 
        // detect up dir
        if (i >= 1 && p[i] == '.' && p[i-1] == '.' && (i < 2 || p[i - 2] == '/')) {
            ++up;
            i -= i >= 2 ? 3 : 2;
 
            if (isRemote) {
                // moving up should consider empty path segments too (/path//../ -> /path/)
                while (i > 0 && up && p[i] == '/') {
                    --up;
                    --i;
                }
            }
            continue;
        }
 
        // prepend a slash before copying when not empty
        if (!up && used != len && out[used] != '/')
            out[--used] = '/';
 
        // skip or copy
        while (i >= 0) {
            if (p[i] == '/') {
                // copy all slashes as is for remote urls if they are not part of /./ or /../
                if (isRemote && !up) {
                    while (i > 0 && p[i] == '/' && !isDotDot(p, i)) {
 
                        if (isDot(p, i)) {
                            i -= 2;
                            continue;
                        }
 
                        out[--used] = p[i];
                        --i;
                    }
 
                    // in case of /./, jump over
                    if (isDot(p, i))
                        i -= 2;
 
                    break;
                }
 
                --i;
                break;
            }
 
            // actual copy
            if (!up)
                out[--used] = p[i];
            --i;
        }
 
        // decrement up after copying/skipping
        if (up)
            --up;
    }
 
    // Indicate failure when ".." are left over for an absolute path.
    if (ok)
        *ok = prefixLength == 0 || up == 0;
 
    // add remaining '..'
    while (up && !isRemote) {
        if (used != len && out[used] != '/') // is not empty and there isn't already a '/'
            out[--used] = '/';
        out[--used] = '.';
        out[--used] = '.';
        --up;
    }
 
    bool isEmpty = used == len;
 
    if (prefixLength) {
        if (!isEmpty && out[used] == '/') {
            // Even though there is a prefix the out string is a slash. This happens, if the input
            // string only consists of a prefix followed by one or more slashes. Just skip the slash.
            ++used;
        }
        for (qsizetype i = prefixLength - 1; i >= 0; --i)
            out[--used] = prefix[i];
    } else {
        if (isEmpty) {
            // After resolving the input path, the resulting string is empty (e.g. "foo/.."). Return
            // a dot in that case.
            out[--used] = '.';
        } else if (out[used] == '/') {
            // After parsing the input string, out only contains a slash. That happens whenever all
            // parts are resolved and there is a trailing slash ("./" or "foo/../" for example).
            // Prepend a dot to have the correct return value.
            out[--used] = '.';
        }
    }
 
    // If path was not modified return the original value
    if (used == 0)
        return name;
    return QString::fromUtf16(out + used, len - used);
}
 
static QString qt_cleanPath(const QString &path, bool *ok)
{
    if (path.isEmpty()) {
        Q_ASSERT(!ok); // The only caller passing ok knows its path is non-empty
        return path;
    }
 
    QString name = QDir::fromNativeSeparators(path);
    QString ret = qt_normalizePathSegments(name, OSSupportsUncPaths ? QDirPrivate::AllowUncPaths : QDirPrivate::DefaultNormalization, ok);
 
    // Strip away last slash except for root directories
    if (ret.size() > 1 && ret.endsWith(u'/')) {
#if defined (Q_OS_WIN)
        if (!(ret.length() == 3 && ret.at(1) == u':'))
#endif
            ret.chop(1);
    }
 
    return ret;
}
 
QString QDir::cleanPath(const QString &path)
{
    return qt_cleanPath(path);
}
 
bool QDir::isRelativePath(const QString &path)
{
    return QFileInfo(path).isRelative();
}
 
void QDir::refresh() const
{
    QDirPrivate *d = const_cast<QDir *>(this)->d_func();
    d->clearCache(QDirPrivate::IncludingMetaData);
}
 
QDirPrivate* QDir::d_func()
{
    return d_ptr.data();
}
 
QStringList QDir::nameFiltersFromString(const QString &nameFilter)
{
    return QDirPrivate::splitFilters(nameFilter);
}
 
#ifndef QT_NO_DEBUG_STREAM
QDebug operator<<(QDebug debug, QDir::Filters filters)
{
    QDebugStateSaver save(debug);
    debug.resetFormat();
    QStringList flags;
    if (filters == QDir::NoFilter) {
        flags << "NoFilter"_L1;
    } else {
        if (filters & QDir::Dirs) flags << "Dirs"_L1;
        if (filters & QDir::AllDirs) flags << "AllDirs"_L1;
        if (filters & QDir::Files) flags << "Files"_L1;
        if (filters & QDir::Drives) flags << "Drives"_L1;
        if (filters & QDir::NoSymLinks) flags << "NoSymLinks"_L1;
        if (filters & QDir::NoDot) flags << "NoDot"_L1;
        if (filters & QDir::NoDotDot) flags << "NoDotDot"_L1;
        if ((filters & QDir::AllEntries) == QDir::AllEntries) flags << "AllEntries"_L1;
        if (filters & QDir::Readable) flags << "Readable"_L1;
        if (filters & QDir::Writable) flags << "Writable"_L1;
        if (filters & QDir::Executable) flags << "Executable"_L1;
        if (filters & QDir::Modified) flags << "Modified"_L1;
        if (filters & QDir::Hidden) flags << "Hidden"_L1;
        if (filters & QDir::System) flags << "System"_L1;
        if (filters & QDir::CaseSensitive) flags << "CaseSensitive"_L1;
    }
    debug.noquote() << "QDir::Filters(" << flags.join(u'|') << ')';
    return debug;
}
 
static QDebug operator<<(QDebug debug, QDir::SortFlags sorting)
{
    QDebugStateSaver save(debug);
    debug.resetFormat();
    if (sorting == QDir::NoSort) {
        debug << "QDir::SortFlags(NoSort)";
    } else {
        QString type;
        if ((sorting & QDir::SortByMask) == QDir::Name) type = "Name"_L1;
        if ((sorting & QDir::SortByMask) == QDir::Time) type = "Time"_L1;
        if ((sorting & QDir::SortByMask) == QDir::Size) type = "Size"_L1;
        if ((sorting & QDir::SortByMask) == QDir::Unsorted) type = "Unsorted"_L1;
 
        QStringList flags;
        if (sorting & QDir::DirsFirst) flags << "DirsFirst"_L1;
        if (sorting & QDir::DirsLast) flags << "DirsLast"_L1;
        if (sorting & QDir::IgnoreCase) flags << "IgnoreCase"_L1;
        if (sorting & QDir::LocaleAware) flags << "LocaleAware"_L1;
        if (sorting & QDir::Type) flags << "Type"_L1;
        debug.noquote() << "QDir::SortFlags(" << type << '|' << flags.join(u'|') << ')';
    }
    return debug;
}
 
QDebug operator<<(QDebug debug, const QDir &dir)
{
    QDebugStateSaver save(debug);
    debug.resetFormat();
    debug << "QDir(" << dir.path() << ", nameFilters = {"
          << dir.nameFilters().join(u',')
          << "}, "
          << dir.sorting()
          << ','
          << dir.filter()
          << ')';
    return debug;
}
#endif // QT_NO_DEBUG_STREAM
 
QT_END_NAMESPACE