qdirlisting.cpp

Go to the documentation of this file.

// Copyright (C) 2016 The Qt Company Ltd.
// Copyright (C) 2024 Ahmad Samir <a.samirh78@gmail.com>
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
 
#include "qdirlisting.h"
#include "qdirentryinfo_p.h"
 
#include "qdir_p.h"
#include "qabstractfileengine_p.h"
 
#include <QtCore/qset.h>
 
#if QT_CONFIG(regularexpression)
#include <QtCore/qregularexpression.h>
#endif
 
#include <QtCore/private/qfilesystemiterator_p.h>
#include <QtCore/private/qfilesystementry_p.h>
#include <QtCore/private/qfilesystemmetadata_p.h>
#include <QtCore/private/qfilesystemengine_p.h>
#include <QtCore/private/qfileinfo_p.h>
#include <QtCore/private/qduplicatetracker_p.h>
 
#include <memory>
#include <stack>
#include <vector>
 
QT_BEGIN_NAMESPACE
 
using namespace Qt::StringLiterals;
 
class QDirListingPrivate
{
public:
    void init(bool resolveEngine);
    void advance();
 
    bool entryMatches(QDirEntryInfo &info);
    void pushDirectory(QDirEntryInfo &info);
    void pushInitialDirectory();
 
    void checkAndPushDirectory(QDirEntryInfo &info);
    bool matchesFilters(QDirEntryInfo &data) const;
    bool hasIterators() const;
 
    std::unique_ptr<QAbstractFileEngine> engine;
    QDirEntryInfo initialEntryInfo;
    QStringList nameFilters;
    QDir::Filters filters;
    QDirListing::IteratorFlags iteratorFlags;
    QDirEntryInfo currentEntryInfo;
 
#if QT_CONFIG(regularexpression)
    QList<QRegularExpression> nameRegExps;
#endif
 
    using FEngineIteratorPtr = std::unique_ptr<QAbstractFileEngineIterator>;
    std::stack<FEngineIteratorPtr, std::vector<FEngineIteratorPtr>> fileEngineIterators;
#ifndef QT_NO_FILESYSTEMITERATOR
    using FsIteratorPtr = std::unique_ptr<QFileSystemIterator>;
    std::stack<FsIteratorPtr, std::vector<FsIteratorPtr>> nativeIterators;
#endif
 
    // Loop protection
    QDuplicateTracker<QString> visitedLinks;
};
 
void QDirListingPrivate::init(bool resolveEngine = true)
{
    if (nameFilters.contains("*"_L1))
        nameFilters.clear();
 
    if (filters == QDir::NoFilter)
        filters = QDir::AllEntries;
 
#if QT_CONFIG(regularexpression)
    nameRegExps.reserve(nameFilters.size());
    const auto cs = filters.testAnyFlags(QDir::CaseSensitive) ? Qt::CaseSensitive
                                                              : Qt::CaseInsensitive;
    for (const auto &filter : nameFilters)
        nameRegExps.emplace_back(QRegularExpression::fromWildcard(filter, cs));
#endif
 
    if (resolveEngine) {
        engine = QFileSystemEngine::createLegacyEngine(initialEntryInfo.entry,
                                                       initialEntryInfo.metaData);
    }
 
    pushDirectory(initialEntryInfo);
}
 
void QDirListingPrivate::pushDirectory(QDirEntryInfo &entryInfo)
{
    const QString path = [&entryInfo] {
#ifdef Q_OS_WIN
        if (entryInfo.isSymLink())
            return entryInfo.canonicalFilePath();
#endif
        return entryInfo.filePath();
    }();
 
 
    if (iteratorFlags.testAnyFlags(QDirListing::IteratorFlag::FollowSymlinks)) {
        // Stop link loops
        if (visitedLinks.hasSeen(entryInfo.canonicalFilePath()))
            return;
    }
 
    if (engine) {
        engine->setFileName(path);
        if (auto it = engine->beginEntryList(path, filters, nameFilters)) {
            fileEngineIterators.emplace(std::move(it));
        } else {
            // No iterator; no entry list.
        }
    } else {
#ifndef QT_NO_FILESYSTEMITERATOR
        QFileSystemEntry *fentry = nullptr;
        if (entryInfo.fileInfoOpt)
            fentry = &entryInfo.fileInfoOpt->d_ptr->fileEntry;
        else
            fentry = &entryInfo.entry;
        nativeIterators.emplace(std::make_unique<QFileSystemIterator>(*fentry, filters));
#else
        qWarning("Qt was built with -no-feature-filesystemiterator: no files/plugins will be found!");
#endif
    }
}
 
bool QDirListingPrivate::entryMatches(QDirEntryInfo &entryInfo)
{
    checkAndPushDirectory(entryInfo);
    return matchesFilters(entryInfo);
}
 
void QDirListingPrivate::advance()
{
    // Use get() in both code paths below because the iterator returned by top()
    // may be invalidated due to reallocation when appending new iterators in
    // pushDirectory().
 
    if (engine) {
        while (!fileEngineIterators.empty()) {
            // Find the next valid iterator that matches the filters.
            QAbstractFileEngineIterator *it;
            while (it = fileEngineIterators.top().get(), it->advance()) {
                QDirEntryInfo entryInfo;
                entryInfo.fileInfoOpt = it->currentFileInfo();
                if (entryMatches(entryInfo)) {
                    currentEntryInfo = std::move(entryInfo);
                    return;
                }
            }
 
            fileEngineIterators.pop();
        }
    } else {
#ifndef QT_NO_FILESYSTEMITERATOR
        QDirEntryInfo entryInfo;
        while (!nativeIterators.empty()) {
            // Find the next valid iterator that matches the filters.
            QFileSystemIterator *it;
            while (it = nativeIterators.top().get(), it->advance(entryInfo.entry, entryInfo.metaData)) {
                if (entryMatches(entryInfo)) {
                    currentEntryInfo = std::move(entryInfo);
                    return;
                }
                entryInfo = {};
            }
 
            nativeIterators.pop();
        }
#endif
    }
}
 
void QDirListingPrivate::checkAndPushDirectory(QDirEntryInfo &entryInfo)
{
    using F = QDirListing::IteratorFlag;
    // If we're doing flat iteration, we're done.
    if (!iteratorFlags.testAnyFlags(F::Recursive))
        return;
 
    // Never follow non-directory entries
    if (!entryInfo.isDir())
        return;
 
    // Follow symlinks only when asked
    if (!iteratorFlags.testAnyFlags(F::FollowSymlinks) && entryInfo.isSymLink())
        return;
 
    // Never follow . and ..
    const QString &fileName = entryInfo.fileName();
    if ("."_L1 == fileName || ".."_L1 == fileName)
        return;
 
    // No hidden directories unless requested
    if (!filters.testAnyFlags(QDir::AllDirs | QDir::Hidden) && entryInfo.isHidden())
        return;
 
    pushDirectory(entryInfo);
}
 
bool QDirListingPrivate::matchesFilters(QDirEntryInfo &entryInfo) const
{
    const QString &fileName = entryInfo.fileName();
    if (fileName.isEmpty())
        return false;
 
    // filter . and ..?
    const qsizetype fileNameSize = fileName.size();
    const bool dotOrDotDot = fileName[0] == u'.'
                             && ((fileNameSize == 1)
                                 ||(fileNameSize == 2 && fileName[1] == u'.'));
    if ((filters & QDir::NoDot) && dotOrDotDot && fileNameSize == 1)
        return false;
    if ((filters & QDir::NoDotDot) && dotOrDotDot && fileNameSize == 2)
        return false;
 
    // name filter
#if QT_CONFIG(regularexpression)
    // Pass all entries through name filters, except dirs if AllDirs is set
    if (!nameRegExps.isEmpty() && !(filters.testAnyFlags(QDir::AllDirs) && entryInfo.isDir())) {
        auto regexMatchesName = [&fileName](const auto &re) {
            return re.match(fileName).hasMatch();
        };
        if (std::none_of(nameRegExps.cbegin(), nameRegExps.cend(), regexMatchesName))
            return false;
    }
#endif
    // skip symlinks
    const bool skipSymlinks = filters.testAnyFlag(QDir::NoSymLinks);
    const bool includeSystem = filters.testAnyFlag(QDir::System);
    if (skipSymlinks && entryInfo.isSymLink()) {
        // The only reason to save this file is if it is a broken link and we are requesting system files.
        if (!includeSystem || entryInfo.exists())
            return false;
    }
 
    // filter hidden
    const bool includeHidden = filters.testAnyFlag(QDir::Hidden);
    if (!includeHidden && !dotOrDotDot && entryInfo.isHidden())
        return false;
 
    // filter system files
    if (!includeSystem) {
        if (!entryInfo.isFile() && !entryInfo.isDir() && !entryInfo.isSymLink())
            return false;
        if (entryInfo.isSymLink() && !entryInfo.exists())
            return false;
    }
 
    // skip directories
    const bool skipDirs = !(filters & (QDir::Dirs | QDir::AllDirs));
    if (skipDirs && entryInfo.isDir())
        return false;
 
    // skip files
    const bool skipFiles    = !(filters & QDir::Files);
    if (skipFiles && entryInfo.isFile())
        // Basically we need a reason not to exclude this file otherwise we just eliminate it.
        return false;
 
    // filter permissions
    const auto perms = filters & QDir::PermissionMask;
    const bool filterPermissions = perms != 0 && perms != QDir::PermissionMask;
    if (filterPermissions) {
        const bool doWritable = filters.testAnyFlags(QDir::Writable);
        const bool doExecutable = filters.testAnyFlags(QDir::Executable);
        const bool doReadable = filters.testAnyFlags(QDir::Readable);
        if ((doReadable && !entryInfo.isReadable())
            || (doWritable && !entryInfo.isWritable())
            || (doExecutable && !entryInfo.isExecutable())) {
            return false;
        }
    }
 
    return true;
}
 
bool QDirListingPrivate::hasIterators() const
{
    if (engine)
        return !fileEngineIterators.empty();
 
#if !defined(QT_NO_FILESYSTEMITERATOR)
    return !nativeIterators.empty();
#endif
 
    return false;
}
 
QDirListing::QDirListing(const QDir &dir, IteratorFlags flags)
    : d(new QDirListingPrivate)
{
    const QDirPrivate *other = dir.d_ptr.constData();
    d->initialEntryInfo.entry = other->dirEntry;
    d->nameFilters = other->nameFilters;
    d->filters = other->filters;
    d->iteratorFlags = flags;
    const bool resolveEngine = other->fileEngine ? true : false;
    d->init(resolveEngine);
}
 
QDirListing::QDirListing(const QString &path, QDir::Filters filters, IteratorFlags flags)
    : d(new QDirListingPrivate)
{
    d->initialEntryInfo.entry = QFileSystemEntry(path);
    d->filters = filters;
    d->iteratorFlags = flags;
    d->init();
}
 
QDirListing::QDirListing(const QString &path, IteratorFlags flags)
    : d(new QDirListingPrivate)
{
    d->initialEntryInfo.entry = QFileSystemEntry(path);
    d->filters = QDir::NoFilter;
    d->iteratorFlags = flags;
    d->init();
}
 
QDirListing::QDirListing(const QString &path, const QStringList &nameFilters, QDir::Filters filters,
                         IteratorFlags flags)
    : d(new QDirListingPrivate)
{
    d->initialEntryInfo.entry = QFileSystemEntry(path);
    d->nameFilters = nameFilters;
    d->filters = filters;
    d->iteratorFlags = flags;
    d->init();
}
 
QDirListing::~QDirListing() = default;
 
QString QDirListing::iteratorPath() const
{
    return d->initialEntryInfo.filePath();
}
 
QDirListing::const_iterator QDirListing::begin() const
{
    const_iterator it{d.get()};
    return ++it;
}
 
QDirListing::const_iterator &QDirListing::const_iterator::operator++()
{
    dirListPtr->advance();
    if (!dirListPtr->hasIterators())
        *this = {}; // All done, make `this` the end() iterator
    return *this;
}
 
QFileInfo QDirListing::DirEntry::fileInfo() const
{
    return dirListPtr->currentEntryInfo.fileInfo();
}
 
QString QDirListing::DirEntry::fileName() const
{
    return dirListPtr->currentEntryInfo.fileName();
}
 
QString QDirListing::DirEntry::baseName() const
{
    return dirListPtr->currentEntryInfo.baseName();
}
 
QString QDirListing::DirEntry::completeBaseName() const
{
    return dirListPtr->currentEntryInfo.completeBaseName();
}
 
QString QDirListing::DirEntry::suffix() const
{
    return dirListPtr->currentEntryInfo.suffix();
}
 
QString QDirListing::DirEntry::bundleName() const
{
    return dirListPtr->currentEntryInfo.bundleName();
}
 
QString QDirListing::DirEntry::completeSuffix() const
{
    return dirListPtr->currentEntryInfo.completeSuffix();
}
 
QString QDirListing::DirEntry::filePath() const
{
    return dirListPtr->currentEntryInfo.filePath();
}
 
QString QDirListing::DirEntry::canonicalFilePath() const
{
    return dirListPtr->currentEntryInfo.canonicalFilePath();
}
 
QString QDirListing::DirEntry::absoluteFilePath() const
{
    return dirListPtr->currentEntryInfo.absoluteFilePath();
}
 
QString QDirListing::DirEntry::absolutePath() const
{
    return dirListPtr->currentEntryInfo.absolutePath();
}
 
bool QDirListing::DirEntry::isDir() const
{
    return dirListPtr->currentEntryInfo.isDir();
}
 
bool QDirListing::DirEntry::isFile() const
{
    return dirListPtr->currentEntryInfo.isFile();
}
 
bool QDirListing::DirEntry::isSymLink() const
{
    return dirListPtr->currentEntryInfo.isSymLink();
}
 
bool QDirListing::DirEntry::exists() const
{
    return dirListPtr->currentEntryInfo.exists();
}
 
bool QDirListing::DirEntry::isHidden() const
{
    return dirListPtr->currentEntryInfo.isHidden();
}
 
bool QDirListing::DirEntry::isReadable() const
{
    return dirListPtr->currentEntryInfo.isReadable();
}
 
bool QDirListing::DirEntry::isWritable() const
{
    return dirListPtr->currentEntryInfo.isWritable();
}
 
bool QDirListing::DirEntry::isExecutable() const
{
    return dirListPtr->currentEntryInfo.isExecutable();
}
 
qint64 QDirListing::DirEntry::size() const
{
    return dirListPtr->currentEntryInfo.size();
}
 
QDateTime QDirListing::DirEntry::fileTime(QFile::FileTime type, const QTimeZone &tz) const
{
    return dirListPtr->currentEntryInfo.fileTime(type, tz);
}
 
QT_END_NAMESPACE