mirror of https://github.com/qt/qtbase.git
2615 lines
80 KiB
C++
2615 lines
80 KiB
C++
/****************************************************************************
|
|
**
|
|
** Copyright (C) 2016 The Qt Company Ltd.
|
|
** Contact: https://www.qt.io/licensing/
|
|
**
|
|
** This file is part of the QtCore module of the Qt Toolkit.
|
|
**
|
|
** $QT_BEGIN_LICENSE:LGPL$
|
|
** Commercial License Usage
|
|
** Licensees holding valid commercial Qt licenses may use this file in
|
|
** accordance with the commercial license agreement provided with the
|
|
** Software or, alternatively, in accordance with the terms contained in
|
|
** a written agreement between you and The Qt Company. For licensing terms
|
|
** and conditions see https://www.qt.io/terms-conditions. For further
|
|
** information use the contact form at https://www.qt.io/contact-us.
|
|
**
|
|
** GNU Lesser General Public License Usage
|
|
** Alternatively, this file may be used under the terms of the GNU Lesser
|
|
** General Public License version 3 as published by the Free Software
|
|
** Foundation and appearing in the file LICENSE.LGPL3 included in the
|
|
** packaging of this file. Please review the following information to
|
|
** ensure the GNU Lesser General Public License version 3 requirements
|
|
** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.
|
|
**
|
|
** GNU General Public License Usage
|
|
** Alternatively, this file may be used under the terms of the GNU
|
|
** General Public License version 2.0 or (at your option) the GNU General
|
|
** Public license version 3 or any later version approved by the KDE Free
|
|
** Qt Foundation. The licenses are as published by the Free Software
|
|
** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3
|
|
** included in the packaging of this file. Please review the following
|
|
** information to ensure the GNU General Public License requirements will
|
|
** be met: https://www.gnu.org/licenses/gpl-2.0.html and
|
|
** https://www.gnu.org/licenses/gpl-3.0.html.
|
|
**
|
|
** $QT_END_LICENSE$
|
|
**
|
|
****************************************************************************/
|
|
|
|
#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>
|
|
|
|
#ifdef QT_BUILD_CORE_LIB
|
|
# include "qresource.h"
|
|
# include "private/qcoreglobaldata_p.h"
|
|
#endif
|
|
|
|
#include <algorithm>
|
|
#include <stdlib.h>
|
|
|
|
QT_BEGIN_NAMESPACE
|
|
|
|
#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 int rootLength(const QString &name, bool allowUncPaths)
|
|
{
|
|
const int len = name.length();
|
|
// starts with double slash
|
|
if (allowUncPaths && name.startsWith(QLatin1String("//"))) {
|
|
// Server name '//server/path' is part of the prefix.
|
|
const int nextSlash = name.indexOf(QLatin1Char('/'), 2);
|
|
return nextSlash >= 0 ? nextSlash + 1 : len;
|
|
}
|
|
#if defined(Q_OS_WIN)
|
|
if (len >= 2 && name.at(1) == QLatin1Char(':')) {
|
|
// Handle a possible drive letter
|
|
return len > 2 && name.at(2) == QLatin1Char('/') ? 3 : 2;
|
|
}
|
|
#endif
|
|
if (name.at(0) == QLatin1Char('/'))
|
|
return 1;
|
|
return 0;
|
|
}
|
|
|
|
//************* QDirPrivate
|
|
QDirPrivate::QDirPrivate(const QString &path, const QStringList &nameFilters_, QDir::SortFlags sort_, QDir::Filters filters_)
|
|
: QSharedData()
|
|
, fileListsInitialized(false)
|
|
, nameFilters(nameFilters_)
|
|
, sort(sort_)
|
|
, filters(filters_)
|
|
{
|
|
setPath(path.isEmpty() ? QString::fromLatin1(".") : path);
|
|
|
|
bool empty = nameFilters.isEmpty();
|
|
if (!empty) {
|
|
empty = true;
|
|
for (int i = 0; i < nameFilters.size(); ++i) {
|
|
if (!nameFilters.at(i).isEmpty()) {
|
|
empty = false;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
if (empty)
|
|
nameFilters = QStringList(QString::fromLatin1("*"));
|
|
}
|
|
|
|
QDirPrivate::QDirPrivate(const QDirPrivate ©)
|
|
: QSharedData(copy)
|
|
, fileListsInitialized(false)
|
|
, nameFilters(copy.nameFilters)
|
|
, sort(copy.sort)
|
|
, filters(copy.filters)
|
|
, dirEntry(copy.dirEntry)
|
|
, metaData(copy.metaData)
|
|
{
|
|
}
|
|
|
|
bool QDirPrivate::exists() const
|
|
{
|
|
if (!fileEngine) {
|
|
QFileSystemEngine::fillMetaData(dirEntry, metaData,
|
|
QFileSystemMetaData::ExistsAttribute | QFileSystemMetaData::DirectoryType); // always stat
|
|
return metaData.exists() && metaData.isDirectory();
|
|
}
|
|
const QAbstractFileEngine::FileFlags info =
|
|
fileEngine->fileFlags(QAbstractFileEngine::DirectoryType
|
|
| QAbstractFileEngine::ExistsFlag
|
|
| QAbstractFileEngine::Refresh);
|
|
if (!(info & QAbstractFileEngine::DirectoryType))
|
|
return false;
|
|
return info & QAbstractFileEngine::ExistsFlag;
|
|
}
|
|
|
|
// static
|
|
inline QChar QDirPrivate::getFilterSepChar(const QString &nameFilter)
|
|
{
|
|
QChar sep(QLatin1Char(';'));
|
|
int i = nameFilter.indexOf(sep, 0);
|
|
if (i == -1 && nameFilter.indexOf(QLatin1Char(' '), 0) != -1)
|
|
sep = QChar(QLatin1Char(' '));
|
|
return sep;
|
|
}
|
|
|
|
// static
|
|
inline QStringList QDirPrivate::splitFilters(const QString &nameFilter, QChar sep)
|
|
{
|
|
if (sep.isNull())
|
|
sep = getFilterSepChar(nameFilter);
|
|
const auto split = QStringView{nameFilter}.split(sep);
|
|
QStringList ret;
|
|
ret.reserve(split.size());
|
|
for (const auto &e : split)
|
|
ret.append(e.trimmed().toString());
|
|
return ret;
|
|
}
|
|
|
|
inline void QDirPrivate::setPath(const QString &path)
|
|
{
|
|
QString p = QDir::fromNativeSeparators(path);
|
|
if (p.endsWith(QLatin1Char('/'))
|
|
&& p.length() > 1
|
|
#if defined(Q_OS_WIN)
|
|
&& (!(p.length() == 3 && p.at(1).unicode() == ':' && p.at(0).isLetter()))
|
|
#endif
|
|
) {
|
|
p.truncate(p.length() - 1);
|
|
}
|
|
|
|
dirEntry = QFileSystemEntry(p, QFileSystemEntry::FromInternalPath());
|
|
metaData.clear();
|
|
initFileEngine();
|
|
clearFileLists();
|
|
absoluteDirEntry = QFileSystemEntry();
|
|
}
|
|
|
|
inline void QDirPrivate::clearFileLists()
|
|
{
|
|
fileListsInitialized = false;
|
|
files.clear();
|
|
fileInfos.clear();
|
|
}
|
|
|
|
inline void QDirPrivate::resolveAbsoluteEntry() const
|
|
{
|
|
if (!absoluteDirEntry.isEmpty() || dirEntry.isEmpty())
|
|
return;
|
|
|
|
QString absoluteName;
|
|
if (!fileEngine) {
|
|
if (!dirEntry.isRelative() && dirEntry.isClean()) {
|
|
absoluteDirEntry = dirEntry;
|
|
return;
|
|
}
|
|
|
|
absoluteName = QFileSystemEngine::absoluteName(dirEntry).filePath();
|
|
} else {
|
|
absoluteName = fileEngine->fileName(QAbstractFileEngine::AbsoluteName);
|
|
}
|
|
|
|
absoluteDirEntry = QFileSystemEntry(QDir::cleanPath(absoluteName), QFileSystemEntry::FromInternalPath());
|
|
}
|
|
|
|
/* For sorting */
|
|
struct QDirSortItem
|
|
{
|
|
mutable QString filename_cache;
|
|
mutable QString suffix_cache;
|
|
QFileInfo item;
|
|
};
|
|
|
|
|
|
class QDirSortItemComparator
|
|
{
|
|
int qt_cmp_si_sort_flags;
|
|
public:
|
|
QDirSortItemComparator(int flags) : qt_cmp_si_sort_flags(flags) {}
|
|
bool operator()(const QDirSortItem &, const QDirSortItem &) const;
|
|
};
|
|
|
|
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();
|
|
|
|
qint64 r = 0;
|
|
int sortBy = (qt_cmp_si_sort_flags & QDir::SortByMask)
|
|
| (qt_cmp_si_sort_flags & QDir::Type);
|
|
|
|
switch (sortBy) {
|
|
case QDir::Time: {
|
|
QDateTime firstModified = f1->item.lastModified();
|
|
QDateTime secondModified = f2->item.lastModified();
|
|
|
|
// QDateTime by default will do all sorts of conversions on these to
|
|
// find timezones, which is incredibly expensive. As we aren't
|
|
// presenting these to the user, we don't care (at all) about the
|
|
// local timezone, so force them to UTC to avoid that conversion.
|
|
firstModified.setTimeSpec(Qt::UTC);
|
|
secondModified.setTimeSpec(Qt::UTC);
|
|
|
|
r = firstModified.msecsTo(secondModified);
|
|
break;
|
|
}
|
|
case QDir::Size:
|
|
r = f2->item.size() - f1->item.size();
|
|
break;
|
|
case QDir::Type:
|
|
{
|
|
bool ic = qt_cmp_si_sort_flags & QDir::IgnoreCase;
|
|
|
|
if (f1->suffix_cache.isNull())
|
|
f1->suffix_cache = ic ? f1->item.suffix().toLower()
|
|
: f1->item.suffix();
|
|
if (f2->suffix_cache.isNull())
|
|
f2->suffix_cache = ic ? f2->item.suffix().toLower()
|
|
: f2->item.suffix();
|
|
|
|
r = qt_cmp_si_sort_flags & QDir::LocaleAware
|
|
? f1->suffix_cache.localeAwareCompare(f2->suffix_cache)
|
|
: f1->suffix_cache.compare(f2->suffix_cache);
|
|
}
|
|
break;
|
|
default:
|
|
;
|
|
}
|
|
|
|
if (r == 0 && sortBy != QDir::Unsorted) {
|
|
// Still not sorted - sort by name
|
|
bool ic = qt_cmp_si_sort_flags & QDir::IgnoreCase;
|
|
|
|
if (f1->filename_cache.isNull())
|
|
f1->filename_cache = ic ? f1->item.fileName().toLower()
|
|
: f1->item.fileName();
|
|
if (f2->filename_cache.isNull())
|
|
f2->filename_cache = ic ? f2->item.fileName().toLower()
|
|
: f2->item.fileName();
|
|
|
|
r = qt_cmp_si_sort_flags & QDir::LocaleAware
|
|
? f1->filename_cache.localeAwareCompare(f2->filename_cache)
|
|
: f1->filename_cache.compare(f2->filename_cache);
|
|
}
|
|
if (qt_cmp_si_sort_flags & QDir::Reversed)
|
|
return r > 0;
|
|
return r < 0;
|
|
}
|
|
|
|
inline void QDirPrivate::sortFileList(QDir::SortFlags sort, QFileInfoList &l,
|
|
QStringList *names, QFileInfoList *infos)
|
|
{
|
|
// names and infos are always empty lists or 0 here
|
|
int n = l.size();
|
|
if (n > 0) {
|
|
if (n == 1 || (sort & QDir::SortByMask) == QDir::Unsorted) {
|
|
if (infos)
|
|
*infos = l;
|
|
if (names) {
|
|
for (int i = 0; i < n; ++i)
|
|
names->append(l.at(i).fileName());
|
|
}
|
|
} else {
|
|
QScopedArrayPointer<QDirSortItem> si(new QDirSortItem[n]);
|
|
for (int i = 0; i < n; ++i)
|
|
si[i].item = l.at(i);
|
|
std::sort(si.data(), si.data() + n, QDirSortItemComparator(sort));
|
|
// put them back in the list(s)
|
|
if (infos) {
|
|
for (int i = 0; i < n; ++i)
|
|
infos->append(si[i].item);
|
|
}
|
|
if (names) {
|
|
for (int i = 0; i < n; ++i)
|
|
names->append(si[i].item.fileName());
|
|
}
|
|
}
|
|
}
|
|
}
|
|
inline void QDirPrivate::initFileLists(const QDir &dir) const
|
|
{
|
|
if (!fileListsInitialized) {
|
|
QFileInfoList l;
|
|
QDirIterator it(dir);
|
|
while (it.hasNext()) {
|
|
it.next();
|
|
l.append(it.fileInfo());
|
|
}
|
|
sortFileList(sort, l, &files, &fileInfos);
|
|
fileListsInitialized = true;
|
|
}
|
|
}
|
|
|
|
inline void QDirPrivate::initFileEngine()
|
|
{
|
|
fileEngine.reset(QFileSystemEngine::resolveEntryAndCreateLegacyEngine(dirEntry, metaData));
|
|
}
|
|
|
|
/*!
|
|
\class QDir
|
|
\inmodule QtCore
|
|
\brief The QDir class provides access to directory structures and their contents.
|
|
|
|
\ingroup io
|
|
\ingroup shared
|
|
\reentrant
|
|
|
|
|
|
A QDir is used to manipulate path names, access information
|
|
regarding paths and files, and manipulate the underlying file
|
|
system. It can also be used to access Qt's \l{resource system}.
|
|
|
|
Qt uses "/" as a universal directory separator in the same way
|
|
that "/" is used as a path separator in URLs. If you always use
|
|
"/" as a directory separator, Qt will translate your paths to
|
|
conform to the underlying operating system.
|
|
|
|
A QDir can point to a file using either a relative or an absolute
|
|
path. Absolute paths begin with the directory separator
|
|
(optionally preceded by a drive specification under Windows).
|
|
Relative file names begin with a directory name or a file name and
|
|
specify a path relative to the current directory.
|
|
|
|
Examples of absolute paths:
|
|
|
|
\snippet code/src_corelib_io_qdir.cpp 0
|
|
|
|
On Windows, the second example above will be translated to
|
|
\c{C:\Documents and Settings} when used to access files.
|
|
|
|
Examples of relative paths:
|
|
|
|
\snippet code/src_corelib_io_qdir.cpp 1
|
|
|
|
You can use the isRelative() or isAbsolute() functions to check if
|
|
a QDir is using a relative or an absolute file path. Call
|
|
makeAbsolute() to convert a relative QDir to an absolute one.
|
|
|
|
\section1 Navigation and Directory Operations
|
|
|
|
A directory's path can be obtained with the path() function, and
|
|
a new path set with the setPath() function. The absolute path to
|
|
a directory is found by calling absolutePath().
|
|
|
|
The name of a directory is found using the dirName() function. This
|
|
typically returns the last element in the absolute path that specifies
|
|
the location of the directory. However, it can also return "." if
|
|
the QDir represents the current directory.
|
|
|
|
\snippet code/src_corelib_io_qdir.cpp 2
|
|
|
|
The path for a directory can also be changed with the cd() and cdUp()
|
|
functions, both of which operate like familiar shell commands.
|
|
When cd() is called with the name of an existing directory, the QDir
|
|
object changes directory so that it represents that directory instead.
|
|
The cdUp() function changes the directory of the QDir object so that
|
|
it refers to its parent directory; i.e. cd("..") is equivalent to
|
|
cdUp().
|
|
|
|
Directories can be created with mkdir(), renamed with rename(), and
|
|
removed with rmdir().
|
|
|
|
You can test for the presence of a directory with a given name by
|
|
using exists(), and the properties of a directory can be tested with
|
|
isReadable(), isAbsolute(), isRelative(), and isRoot().
|
|
|
|
The refresh() function re-reads the directory's data from disk.
|
|
|
|
\section1 Files and Directory Contents
|
|
|
|
Directories contain a number of entries, representing files,
|
|
directories, and symbolic links. The number of entries in a
|
|
directory is returned by count().
|
|
A string list of the names of all the entries in a directory can be
|
|
obtained with entryList(). If you need information about each
|
|
entry, use entryInfoList() to obtain a list of QFileInfo objects.
|
|
|
|
Paths to files and directories within a directory can be
|
|
constructed using filePath() and absoluteFilePath().
|
|
The filePath() function returns a path to the specified file
|
|
or directory relative to the path of the QDir object;
|
|
absoluteFilePath() returns an absolute path to the specified
|
|
file or directory. Neither of these functions checks for the
|
|
existence of files or directory; they only construct paths.
|
|
|
|
\snippet code/src_corelib_io_qdir.cpp 3
|
|
|
|
Files can be removed by using the remove() function. Directories
|
|
cannot be removed in the same way as files; use rmdir() to remove
|
|
them instead.
|
|
|
|
It is possible to reduce the number of entries returned by
|
|
entryList() and entryInfoList() by applying filters to a QDir object.
|
|
You can apply a name filter to specify a pattern with wildcards that
|
|
file names need to match, an attribute filter that selects properties
|
|
of entries and can distinguish between files and directories, and a
|
|
sort order.
|
|
|
|
Name filters are lists of strings that are passed to setNameFilters().
|
|
Attribute filters consist of a bitwise OR combination of Filters, and
|
|
these are specified when calling setFilter().
|
|
The sort order is specified using setSorting() with a bitwise OR
|
|
combination of SortFlags.
|
|
|
|
You can test to see if a filename matches a filter using the match()
|
|
function.
|
|
|
|
Filter and sort order flags may also be specified when calling
|
|
entryList() and entryInfoList() in order to override previously defined
|
|
behavior.
|
|
|
|
\section1 The Current Directory and Other Special Paths
|
|
|
|
Access to some common directories is provided with a number of static
|
|
functions that return QDir objects. There are also corresponding functions
|
|
for these that return strings:
|
|
|
|
\table
|
|
\header \li QDir \li QString \li Return Value
|
|
\row \li current() \li currentPath() \li The application's working directory
|
|
\row \li home() \li homePath() \li The user's home directory
|
|
\row \li root() \li rootPath() \li The root directory
|
|
\row \li temp() \li tempPath() \li The system's temporary directory
|
|
\endtable
|
|
|
|
The setCurrent() static function can also be used to set the application's
|
|
working directory.
|
|
|
|
If you want to find the directory containing the application's executable,
|
|
see \l{QCoreApplication::applicationDirPath()}.
|
|
|
|
The drives() static function provides a list of root directories for each
|
|
device that contains a filing system. On Unix systems this returns a list
|
|
containing a single root directory "/"; on Windows the list will usually
|
|
contain \c{C:/}, and possibly other drive letters such as \c{D:/}, depending
|
|
on the configuration of the user's system.
|
|
|
|
\section1 Path Manipulation and Strings
|
|
|
|
Paths containing "." elements that reference the current directory at that
|
|
point in the path, ".." elements that reference the parent directory, and
|
|
symbolic links can be reduced to a canonical form using the canonicalPath()
|
|
function.
|
|
|
|
Paths can also be simplified by using cleanPath() to remove redundant "/"
|
|
and ".." elements.
|
|
|
|
It is sometimes necessary to be able to show a path in the native
|
|
representation for the user's platform. The static toNativeSeparators()
|
|
function returns a copy of the specified path in which each directory
|
|
separator is replaced by the appropriate separator for the underlying
|
|
operating system.
|
|
|
|
\section1 Examples
|
|
|
|
Check if a directory exists:
|
|
|
|
\snippet code/src_corelib_io_qdir.cpp 4
|
|
|
|
(We could also use the static convenience function
|
|
QFile::exists().)
|
|
|
|
Traversing directories and reading a file:
|
|
|
|
\snippet code/src_corelib_io_qdir.cpp 5
|
|
|
|
A program that lists all the files in the current directory
|
|
(excluding symbolic links), sorted by size, smallest first:
|
|
|
|
\snippet qdir-listfiles/main.cpp 0
|
|
|
|
\sa QFileInfo, QFile, QFileDialog, QCoreApplication::applicationDirPath(), {Find Files Example}
|
|
*/
|
|
|
|
/*!
|
|
\fn QDir &QDir::operator=(QDir &&other)
|
|
|
|
Move-assigns \a other to this QDir instance.
|
|
|
|
\since 5.2
|
|
*/
|
|
|
|
/*!
|
|
\internal
|
|
*/
|
|
QDir::QDir(QDirPrivate &p) : d_ptr(&p)
|
|
{
|
|
}
|
|
|
|
/*!
|
|
Constructs a QDir pointing to the given directory \a path. If path
|
|
is empty the program's working directory, ("."), is used.
|
|
|
|
\sa currentPath()
|
|
*/
|
|
QDir::QDir(const QString &path) : d_ptr(new QDirPrivate(path))
|
|
{
|
|
}
|
|
|
|
/*!
|
|
Constructs a QDir with path \a path, that filters its entries by
|
|
name using \a nameFilter and by attributes using \a filters. It
|
|
also sorts the names using \a sort.
|
|
|
|
The default \a nameFilter is an empty string, which excludes
|
|
nothing; the default \a filters is \l AllEntries, which also
|
|
excludes nothing. The default \a sort is \l Name | \l IgnoreCase,
|
|
i.e. sort by name case-insensitively.
|
|
|
|
If \a path is an empty string, QDir uses "." (the current
|
|
directory). If \a nameFilter is an empty string, QDir uses the
|
|
name filter "*" (all files).
|
|
|
|
Note that \a path need not exist.
|
|
|
|
\sa exists(), setPath(), setNameFilters(), setFilter(), setSorting()
|
|
*/
|
|
QDir::QDir(const QString &path, const QString &nameFilter,
|
|
SortFlags sort, Filters filters)
|
|
: d_ptr(new QDirPrivate(path, QDir::nameFiltersFromString(nameFilter), sort, filters))
|
|
{
|
|
}
|
|
|
|
/*!
|
|
Constructs a QDir object that is a copy of the QDir object for
|
|
directory \a dir.
|
|
|
|
\sa operator=()
|
|
*/
|
|
QDir::QDir(const QDir &dir)
|
|
: d_ptr(dir.d_ptr)
|
|
{
|
|
}
|
|
|
|
/*!
|
|
Destroys the QDir object frees up its resources. This has no
|
|
effect on the underlying directory in the file system.
|
|
*/
|
|
QDir::~QDir()
|
|
{
|
|
}
|
|
|
|
/*!
|
|
Sets the path of the directory to \a path. The path is cleaned of
|
|
redundant ".", ".." and of multiple separators. No check is made
|
|
to see whether a directory with this path actually exists; but you
|
|
can check for yourself using exists().
|
|
|
|
The path can be either absolute or relative. Absolute paths begin
|
|
with the directory separator "/" (optionally preceded by a drive
|
|
specification under Windows). Relative file names begin with a
|
|
directory name or a file name and specify a path relative to the
|
|
current directory. An example of an absolute path is the string
|
|
"/tmp/quartz", a relative path might look like "src/fatlib".
|
|
|
|
\sa path(), absolutePath(), exists(), cleanPath(), dirName(),
|
|
absoluteFilePath(), isRelative(), makeAbsolute()
|
|
*/
|
|
void QDir::setPath(const QString &path)
|
|
{
|
|
d_ptr->setPath(path);
|
|
}
|
|
|
|
/*!
|
|
Returns the path. This may contain symbolic links, but never
|
|
contains redundant ".", ".." or multiple separators.
|
|
|
|
The returned path can be either absolute or relative (see
|
|
setPath()).
|
|
|
|
\sa setPath(), absolutePath(), exists(), cleanPath(), dirName(),
|
|
absoluteFilePath(), toNativeSeparators(), makeAbsolute()
|
|
*/
|
|
QString QDir::path() const
|
|
{
|
|
const QDirPrivate* d = d_ptr.constData();
|
|
return d->dirEntry.filePath();
|
|
}
|
|
|
|
/*!
|
|
Returns the absolute path (a path that starts with "/" or with a
|
|
drive specification), which may contain symbolic links, but never
|
|
contains redundant ".", ".." or multiple separators.
|
|
|
|
\sa setPath(), canonicalPath(), exists(), cleanPath(),
|
|
dirName(), absoluteFilePath()
|
|
*/
|
|
QString QDir::absolutePath() const
|
|
{
|
|
const QDirPrivate* d = d_ptr.constData();
|
|
d->resolveAbsoluteEntry();
|
|
return d->absoluteDirEntry.filePath();
|
|
}
|
|
|
|
/*!
|
|
Returns the canonical path, i.e. a path without symbolic links or
|
|
redundant "." or ".." elements.
|
|
|
|
On systems that do not have symbolic links this function will
|
|
always return the same string that absolutePath() returns. If the
|
|
canonical path does not exist (normally due to dangling symbolic
|
|
links) canonicalPath() returns an empty string.
|
|
|
|
Example:
|
|
|
|
\snippet code/src_corelib_io_qdir.cpp 6
|
|
|
|
\sa path(), absolutePath(), exists(), cleanPath(), dirName(),
|
|
absoluteFilePath()
|
|
*/
|
|
QString QDir::canonicalPath() const
|
|
{
|
|
const QDirPrivate* d = d_ptr.constData();
|
|
if (!d->fileEngine) {
|
|
QFileSystemEntry answer = QFileSystemEngine::canonicalName(d->dirEntry, d->metaData);
|
|
return answer.filePath();
|
|
}
|
|
return d->fileEngine->fileName(QAbstractFileEngine::CanonicalName);
|
|
}
|
|
|
|
/*!
|
|
Returns the name of the directory; this is \e not the same as the
|
|
path, e.g. a directory with the name "mail", might have the path
|
|
"/var/spool/mail". If the directory has no name (e.g. it is the
|
|
root directory) an empty string is returned.
|
|
|
|
No check is made to ensure that a directory with this name
|
|
actually exists; but see exists().
|
|
|
|
\sa path(), filePath(), absolutePath(), absoluteFilePath()
|
|
*/
|
|
QString QDir::dirName() const
|
|
{
|
|
const QDirPrivate* d = d_ptr.constData();
|
|
return d->dirEntry.fileName();
|
|
}
|
|
|
|
|
|
#ifdef Q_OS_WIN
|
|
static int drivePrefixLength(const QString &path)
|
|
{
|
|
// Used to extract path's drive for use as prefix for an "absolute except for drive" path
|
|
const int size = path.length();
|
|
int 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(QLatin1String("//"))) {
|
|
// UNC path; use its //server/share part as "drive" - it's as sane a
|
|
// thing as we can do.
|
|
for (int i = 2; i-- > 0; ) { // 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)));
|
|
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(QLatin1Char(':')) && QFileInfo(path).isAbsolute())
|
|
|| QFileSystemEntry(path).isAbsolute();
|
|
}
|
|
|
|
/*!
|
|
Returns the path name of a file in the directory. Does \e not
|
|
check if the file actually exists in the directory; but see
|
|
exists(). If the QDir is relative the returned path name will also
|
|
be relative. Redundant multiple separators or "." and ".."
|
|
directories in \a fileName are not removed (see cleanPath()).
|
|
|
|
\sa dirName(), absoluteFilePath(), isRelative(), canonicalPath()
|
|
*/
|
|
QString QDir::filePath(const QString &fileName) const
|
|
{
|
|
if (treatAsAbsolute(fileName))
|
|
return fileName;
|
|
|
|
const QDirPrivate* d = d_ptr.constData();
|
|
QString ret = d->dirEntry.filePath();
|
|
if (fileName.isEmpty())
|
|
return ret;
|
|
|
|
#ifdef Q_OS_WIN
|
|
if (fileName.startsWith(QLatin1Char('/')) || fileName.startsWith(QLatin1Char('\\'))) {
|
|
// Handle the "absolute except for drive" case (i.e. \blah not c:\blah):
|
|
const int drive = drivePrefixLength(ret);
|
|
return drive > 0 ? QStringView{ret}.left(drive) % fileName : fileName;
|
|
}
|
|
#endif // Q_OS_WIN
|
|
|
|
if (ret.isEmpty() || ret.endsWith(QLatin1Char('/')))
|
|
return ret % fileName;
|
|
return ret % QLatin1Char('/') % fileName;
|
|
}
|
|
|
|
/*!
|
|
Returns the absolute path name of a file in the directory. Does \e
|
|
not check if the file actually exists in the directory; but see
|
|
exists(). Redundant multiple separators or "." and ".."
|
|
directories in \a fileName are not removed (see cleanPath()).
|
|
|
|
\sa relativeFilePath(), filePath(), canonicalPath()
|
|
*/
|
|
QString QDir::absoluteFilePath(const QString &fileName) const
|
|
{
|
|
if (treatAsAbsolute(fileName))
|
|
return fileName;
|
|
|
|
const QDirPrivate* d = d_ptr.constData();
|
|
d->resolveAbsoluteEntry();
|
|
const QString absoluteDirPath = d->absoluteDirEntry.filePath();
|
|
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(QLatin1Char('/')) || fileName.startsWith(QLatin1Char('\\'))) {
|
|
// Combine absoluteDirPath's drive with fileName
|
|
const int 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(QLatin1Char('/')))
|
|
return absoluteDirPath % QLatin1Char('/') % fileName;
|
|
return absoluteDirPath % fileName;
|
|
}
|
|
|
|
/*!
|
|
Returns the path to \a fileName relative to the directory.
|
|
|
|
\snippet code/src_corelib_io_qdir.cpp 7
|
|
|
|
\sa absoluteFilePath(), filePath(), canonicalPath()
|
|
*/
|
|
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(QLatin1String("//"))
|
|
&& !dir.startsWith(QLatin1String("//"))))
|
|
return file;
|
|
|
|
dir.remove(0, dirDrive.size());
|
|
if (!fileDriveMissing)
|
|
file.remove(0, fileDrive.size());
|
|
#endif
|
|
|
|
QString result;
|
|
const auto dirElts = dir.tokenize(QLatin1Char('/'), Qt::SkipEmptyParts);
|
|
const auto fileElts = file.tokenize(QLatin1Char('/'), 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 += QLatin1String("../");
|
|
++dit;
|
|
}
|
|
|
|
if (fit != fend) {
|
|
while (fit != fend) {
|
|
result += *fit++;
|
|
result += QLatin1Char('/');
|
|
}
|
|
result.chop(1);
|
|
}
|
|
|
|
if (result.isEmpty())
|
|
result = QLatin1String(".");
|
|
return result;
|
|
}
|
|
|
|
/*!
|
|
\since 4.2
|
|
|
|
Returns \a pathName with the '/' separators converted to
|
|
separators that are appropriate for the underlying operating
|
|
system.
|
|
|
|
On Windows, toNativeSeparators("c:/winnt/system32") returns
|
|
"c:\\winnt\\system32".
|
|
|
|
The returned string may be the same as the argument on some
|
|
operating systems, for example on Unix.
|
|
|
|
\sa fromNativeSeparators(), separator()
|
|
*/
|
|
QString QDir::toNativeSeparators(const QString &pathName)
|
|
{
|
|
#if defined(Q_OS_WIN)
|
|
int i = pathName.indexOf(QLatin1Char('/'));
|
|
if (i != -1) {
|
|
QString n(pathName);
|
|
|
|
QChar * const data = n.data();
|
|
data[i++] = QLatin1Char('\\');
|
|
|
|
for (; i < n.length(); ++i) {
|
|
if (data[i] == QLatin1Char('/'))
|
|
data[i] = QLatin1Char('\\');
|
|
}
|
|
|
|
return n;
|
|
}
|
|
#endif
|
|
return pathName;
|
|
}
|
|
|
|
/*!
|
|
\since 4.2
|
|
|
|
Returns \a pathName using '/' as file separator. On Windows,
|
|
for instance, fromNativeSeparators("\c{c:\\winnt\\system32}") returns
|
|
"c:/winnt/system32".
|
|
|
|
The returned string may be the same as the argument on some
|
|
operating systems, for example on Unix.
|
|
|
|
\sa toNativeSeparators(), separator()
|
|
*/
|
|
QString QDir::fromNativeSeparators(const QString &pathName)
|
|
{
|
|
#if defined(Q_OS_WIN)
|
|
int i = pathName.indexOf(QLatin1Char('\\'));
|
|
if (i != -1) {
|
|
QString n(pathName);
|
|
if (n.startsWith(QLatin1String("\\\\?\\"))) {
|
|
n.remove(0, 4);
|
|
i = n.indexOf(QLatin1Char('\\'));
|
|
if (i == -1)
|
|
return n;
|
|
}
|
|
|
|
QChar * const data = n.data();
|
|
data[i++] = QLatin1Char('/');
|
|
|
|
for (; i < n.length(); ++i) {
|
|
if (data[i] == QLatin1Char('\\'))
|
|
data[i] = QLatin1Char('/');
|
|
}
|
|
|
|
return n;
|
|
}
|
|
#endif
|
|
return pathName;
|
|
}
|
|
|
|
static QString qt_cleanPath(const QString &path, bool *ok = nullptr);
|
|
|
|
/*!
|
|
Changes the QDir's directory to \a dirName.
|
|
|
|
Returns \c true if the new directory exists;
|
|
otherwise returns \c false. Note that the logical cd() operation is
|
|
not performed if the new directory does not exist.
|
|
|
|
Calling cd("..") is equivalent to calling cdUp().
|
|
|
|
\sa cdUp(), isReadable(), exists(), path()
|
|
*/
|
|
bool QDir::cd(const QString &dirName)
|
|
{
|
|
// Don't detach just yet.
|
|
const QDirPrivate * const d = d_ptr.constData();
|
|
|
|
if (dirName.isEmpty() || dirName == QLatin1String("."))
|
|
return true;
|
|
QString newPath;
|
|
if (isAbsolutePath(dirName)) {
|
|
newPath = qt_cleanPath(dirName);
|
|
} else {
|
|
newPath = d->dirEntry.filePath();
|
|
if (!newPath.endsWith(QLatin1Char('/')))
|
|
newPath += QLatin1Char('/');
|
|
newPath += dirName;
|
|
if (dirName.indexOf(QLatin1Char('/')) >= 0
|
|
|| dirName == QLatin1String("..")
|
|
|| d->dirEntry.filePath() == QLatin1String(".")) {
|
|
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(QLatin1String(".."))) {
|
|
newPath = QFileInfo(newPath).absoluteFilePath();
|
|
}
|
|
}
|
|
}
|
|
|
|
QScopedPointer<QDirPrivate> dir(new QDirPrivate(*d_ptr.constData()));
|
|
dir->setPath(newPath);
|
|
if (!dir->exists())
|
|
return false;
|
|
|
|
d_ptr = dir.take();
|
|
return true;
|
|
}
|
|
|
|
/*!
|
|
Changes directory by moving one directory up from the QDir's
|
|
current directory.
|
|
|
|
Returns \c true if the new directory exists;
|
|
otherwise returns \c false. Note that the logical cdUp() operation is
|
|
not performed if the new directory does not exist.
|
|
|
|
\sa cd(), isReadable(), exists(), path()
|
|
*/
|
|
bool QDir::cdUp()
|
|
{
|
|
return cd(QString::fromLatin1(".."));
|
|
}
|
|
|
|
/*!
|
|
Returns the string list set by setNameFilters()
|
|
*/
|
|
QStringList QDir::nameFilters() const
|
|
{
|
|
const QDirPrivate* d = d_ptr.constData();
|
|
return d->nameFilters;
|
|
}
|
|
|
|
/*!
|
|
Sets the name filters used by entryList() and entryInfoList() to the
|
|
list of filters specified by \a nameFilters.
|
|
|
|
Each name filter is a wildcard (globbing) filter that understands
|
|
\c{*} and \c{?} wildcards. See \l{QRegularExpression#Wildcard matching}
|
|
{QRegularExpression Wildcard Matching}.
|
|
|
|
For example, the following code sets three name filters on a QDir
|
|
to ensure that only files with extensions typically used for C++
|
|
source files are listed:
|
|
|
|
\snippet qdir-namefilters/main.cpp 0
|
|
|
|
\sa nameFilters(), setFilter()
|
|
*/
|
|
void QDir::setNameFilters(const QStringList &nameFilters)
|
|
{
|
|
QDirPrivate* d = d_ptr.data();
|
|
d->initFileEngine();
|
|
d->clearFileLists();
|
|
|
|
d->nameFilters = nameFilters;
|
|
}
|
|
|
|
#if QT_DEPRECATED_SINCE(5, 13)
|
|
/*!
|
|
\obsolete
|
|
|
|
Use QDir::addSearchPath() with a prefix instead.
|
|
|
|
Adds \a path to the search paths searched in to find resources
|
|
that are not specified with an absolute path. The default search
|
|
path is to search only in the root (\c{:/}).
|
|
|
|
\sa {The Qt Resource System}
|
|
*/
|
|
void QDir::addResourceSearchPath(const QString &path)
|
|
{
|
|
#ifdef QT_BUILD_CORE_LIB
|
|
QT_WARNING_PUSH
|
|
QT_WARNING_DISABLE_DEPRECATED
|
|
QResource::addSearchPath(path);
|
|
QT_WARNING_POP
|
|
#else
|
|
Q_UNUSED(path);
|
|
#endif
|
|
}
|
|
#endif
|
|
|
|
#ifdef QT_BUILD_CORE_LIB
|
|
/*!
|
|
\since 4.3
|
|
|
|
Sets or replaces Qt's search paths for file names with the prefix \a prefix
|
|
to \a searchPaths.
|
|
|
|
To specify a prefix for a file name, prepend the prefix followed by a single
|
|
colon (e.g., "images:undo.png", "xmldocs:books.xml"). \a prefix can only
|
|
contain letters or numbers (e.g., it cannot contain a colon, nor a slash).
|
|
|
|
Qt uses this search path to locate files with a known prefix. The search
|
|
path entries are tested in order, starting with the first entry.
|
|
|
|
\snippet code/src_corelib_io_qdir.cpp 8
|
|
|
|
File name prefix must be at least 2 characters long to avoid conflicts with
|
|
Windows drive letters.
|
|
|
|
Search paths may contain paths to \l{The Qt Resource System}.
|
|
*/
|
|
void QDir::setSearchPaths(const QString &prefix, const QStringList &searchPaths)
|
|
{
|
|
if (prefix.length() < 2) {
|
|
qWarning("QDir::setSearchPaths: Prefix must be longer than 1 character");
|
|
return;
|
|
}
|
|
|
|
for (int i = 0; i < prefix.count(); ++i) {
|
|
if (!prefix.at(i).isLetterOrNumber()) {
|
|
qWarning("QDir::setSearchPaths: Prefix can only contain letters or numbers");
|
|
return;
|
|
}
|
|
}
|
|
|
|
QWriteLocker lock(&QCoreGlobalData::instance()->dirSearchPathsLock);
|
|
QMap<QString, QStringList> &paths = QCoreGlobalData::instance()->dirSearchPaths;
|
|
if (searchPaths.isEmpty()) {
|
|
paths.remove(prefix);
|
|
} else {
|
|
paths.insert(prefix, searchPaths);
|
|
}
|
|
}
|
|
|
|
/*!
|
|
\since 4.3
|
|
|
|
Adds \a path to the search path for \a prefix.
|
|
|
|
\sa setSearchPaths()
|
|
*/
|
|
void QDir::addSearchPath(const QString &prefix, const QString &path)
|
|
{
|
|
if (path.isEmpty())
|
|
return;
|
|
|
|
QWriteLocker lock(&QCoreGlobalData::instance()->dirSearchPathsLock);
|
|
QCoreGlobalData::instance()->dirSearchPaths[prefix] += path;
|
|
}
|
|
|
|
/*!
|
|
\since 4.3
|
|
|
|
Returns the search paths for \a prefix.
|
|
|
|
\sa setSearchPaths(), addSearchPath()
|
|
*/
|
|
QStringList QDir::searchPaths(const QString &prefix)
|
|
{
|
|
QReadLocker lock(&QCoreGlobalData::instance()->dirSearchPathsLock);
|
|
return QCoreGlobalData::instance()->dirSearchPaths.value(prefix);
|
|
}
|
|
|
|
#endif // QT_BUILD_CORE_LIB
|
|
|
|
/*!
|
|
Returns the value set by setFilter()
|
|
*/
|
|
QDir::Filters QDir::filter() const
|
|
{
|
|
const QDirPrivate* d = d_ptr.constData();
|
|
return d->filters;
|
|
}
|
|
|
|
/*!
|
|
\enum QDir::Filter
|
|
|
|
This enum describes the filtering options available to QDir; e.g.
|
|
for entryList() and entryInfoList(). The filter value is specified
|
|
by combining values from the following list using the bitwise OR
|
|
operator:
|
|
|
|
\value Dirs List directories that match the filters.
|
|
\value AllDirs List all directories; i.e. don't apply the filters
|
|
to directory names.
|
|
\value Files List files.
|
|
\value Drives List disk drives (ignored under Unix).
|
|
\value NoSymLinks Do not list symbolic links (ignored by operating
|
|
systems that don't support symbolic links).
|
|
\value NoDotAndDotDot Do not list the special entries "." and "..".
|
|
\value NoDot Do not list the special entry ".".
|
|
\value NoDotDot Do not list the special entry "..".
|
|
\value AllEntries List directories, files, drives and symlinks (this does not list
|
|
broken symlinks unless you specify System).
|
|
\value Readable List files for which the application has read
|
|
access. The Readable value needs to be combined
|
|
with Dirs or Files.
|
|
\value Writable List files for which the application has write
|
|
access. The Writable value needs to be combined
|
|
with Dirs or Files.
|
|
\value Executable List files for which the application has
|
|
execute access. The Executable value needs to be
|
|
combined with Dirs or Files.
|
|
\value Modified Only list files that have been modified (ignored
|
|
on Unix).
|
|
\value Hidden List hidden files (on Unix, files starting with a ".").
|
|
\value System List system files (on Unix, FIFOs, sockets and
|
|
device files are included; on Windows, \c {.lnk}
|
|
files are included)
|
|
\value CaseSensitive The filter should be case sensitive.
|
|
|
|
\omitvalue TypeMask
|
|
\omitvalue AccessMask
|
|
\omitvalue PermissionMask
|
|
\omitvalue NoFilter
|
|
|
|
Functions that use Filter enum values to filter lists of files
|
|
and directories will include symbolic links to files and directories
|
|
unless you set the NoSymLinks value.
|
|
|
|
A default constructed QDir will not filter out files based on
|
|
their permissions, so entryList() and entryInfoList() will return
|
|
all files that are readable, writable, executable, or any
|
|
combination of the three. This makes the default easy to write,
|
|
and at the same time useful.
|
|
|
|
For example, setting the \c Readable, \c Writable, and \c Files
|
|
flags allows all files to be listed for which the application has read
|
|
access, write access or both. If the \c Dirs and \c Drives flags are
|
|
also included in this combination then all drives, directories, all
|
|
files that the application can read, write, or execute, and symlinks
|
|
to such files/directories can be listed.
|
|
|
|
To retrieve the permissons for a directory, use the
|
|
entryInfoList() function to get the associated QFileInfo objects
|
|
and then use the QFileInfo::permissons() to obtain the permissions
|
|
and ownership for each file.
|
|
*/
|
|
|
|
/*!
|
|
Sets the filter used by entryList() and entryInfoList() to \a
|
|
filters. The filter is used to specify the kind of files that
|
|
should be returned by entryList() and entryInfoList(). See
|
|
\l{QDir::Filter}.
|
|
|
|
\sa filter(), setNameFilters()
|
|
*/
|
|
void QDir::setFilter(Filters filters)
|
|
{
|
|
QDirPrivate* d = d_ptr.data();
|
|
d->initFileEngine();
|
|
d->clearFileLists();
|
|
|
|
d->filters = filters;
|
|
}
|
|
|
|
/*!
|
|
Returns the value set by setSorting()
|
|
|
|
\sa setSorting(), SortFlag
|
|
*/
|
|
QDir::SortFlags QDir::sorting() const
|
|
{
|
|
const QDirPrivate* d = d_ptr.constData();
|
|
return d->sort;
|
|
}
|
|
|
|
/*!
|
|
\enum QDir::SortFlag
|
|
|
|
This enum describes the sort options available to QDir, e.g. for
|
|
entryList() and entryInfoList(). The sort value is specified by
|
|
OR-ing together values from the following list:
|
|
|
|
\value Name Sort by name.
|
|
\value Time Sort by time (modification time).
|
|
\value Size Sort by file size.
|
|
\value Type Sort by file type (extension).
|
|
\value Unsorted Do not sort.
|
|
\value NoSort Not sorted by default.
|
|
|
|
\value DirsFirst Put the directories first, then the files.
|
|
\value DirsLast Put the files first, then the directories.
|
|
\value Reversed Reverse the sort order.
|
|
\value IgnoreCase Sort case-insensitively.
|
|
\value LocaleAware Sort items appropriately using the current locale settings.
|
|
|
|
\omitvalue SortByMask
|
|
|
|
You can only specify one of the first four.
|
|
|
|
If you specify both DirsFirst and Reversed, directories are
|
|
still put first, but in reverse order; the files will be listed
|
|
after the directories, again in reverse order.
|
|
*/
|
|
|
|
/*!
|
|
Sets the sort order used by entryList() and entryInfoList().
|
|
|
|
The \a sort is specified by OR-ing values from the enum
|
|
\l{QDir::SortFlag}.
|
|
|
|
\sa sorting(), SortFlag
|
|
*/
|
|
void QDir::setSorting(SortFlags sort)
|
|
{
|
|
QDirPrivate* d = d_ptr.data();
|
|
d->initFileEngine();
|
|
d->clearFileLists();
|
|
|
|
d->sort = sort;
|
|
}
|
|
|
|
/*!
|
|
Returns the total number of directories and files in the directory.
|
|
|
|
Equivalent to entryList().count().
|
|
|
|
\sa operator[](), entryList()
|
|
*/
|
|
uint QDir::count() const
|
|
{
|
|
const QDirPrivate* d = d_ptr.constData();
|
|
d->initFileLists(*this);
|
|
return d->files.count();
|
|
}
|
|
|
|
/*!
|
|
Returns the file name at position \a pos in the list of file
|
|
names. Equivalent to entryList().at(index).
|
|
\a pos must be a valid index position in the list (i.e., 0 <= pos < count()).
|
|
|
|
\sa count(), entryList()
|
|
*/
|
|
QString QDir::operator[](int pos) const
|
|
{
|
|
const QDirPrivate* d = d_ptr.constData();
|
|
d->initFileLists(*this);
|
|
return d->files[pos];
|
|
}
|
|
|
|
/*!
|
|
\overload
|
|
|
|
Returns a list of the names of all the files and directories in
|
|
the directory, ordered according to the name and attribute filters
|
|
previously set with setNameFilters() and setFilter(), and sorted according
|
|
to the flags set with setSorting().
|
|
|
|
The attribute filter and sorting specifications can be overridden using the
|
|
\a filters and \a sort arguments.
|
|
|
|
Returns an empty list if the directory is unreadable, does not
|
|
exist, or if nothing matches the specification.
|
|
|
|
\note To list symlinks that point to non existing files, \l System must be
|
|
passed to the filter.
|
|
|
|
\sa entryInfoList(), setNameFilters(), setSorting(), setFilter()
|
|
*/
|
|
QStringList QDir::entryList(Filters filters, SortFlags sort) const
|
|
{
|
|
const QDirPrivate* d = d_ptr.constData();
|
|
return entryList(d->nameFilters, filters, sort);
|
|
}
|
|
|
|
|
|
/*!
|
|
\overload
|
|
|
|
Returns a list of QFileInfo objects for all the files and directories in
|
|
the directory, ordered according to the name and attribute filters
|
|
previously set with setNameFilters() and setFilter(), and sorted according
|
|
to the flags set with setSorting().
|
|
|
|
The attribute filter and sorting specifications can be overridden using the
|
|
\a filters and \a sort arguments.
|
|
|
|
Returns an empty list if the directory is unreadable, does not
|
|
exist, or if nothing matches the specification.
|
|
|
|
\sa entryList(), setNameFilters(), setSorting(), setFilter(), isReadable(), exists()
|
|
*/
|
|
QFileInfoList QDir::entryInfoList(Filters filters, SortFlags sort) const
|
|
{
|
|
const QDirPrivate* d = d_ptr.constData();
|
|
return entryInfoList(d->nameFilters, filters, sort);
|
|
}
|
|
|
|
/*!
|
|
Returns a list of the names of all the files and
|
|
directories in the directory, ordered according to the name
|
|
and attribute filters previously set with setNameFilters()
|
|
and setFilter(), and sorted according to the flags set with
|
|
setSorting().
|
|
|
|
The name filter, file attribute filter, and sorting specification
|
|
can be overridden using the \a nameFilters, \a filters, and \a sort
|
|
arguments.
|
|
|
|
Returns an empty list if the directory is unreadable, does not
|
|
exist, or if nothing matches the specification.
|
|
|
|
\sa entryInfoList(), setNameFilters(), setSorting(), setFilter()
|
|
*/
|
|
QStringList QDir::entryList(const QStringList &nameFilters, Filters filters,
|
|
SortFlags sort) const
|
|
{
|
|
const QDirPrivate* d = d_ptr.constData();
|
|
|
|
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->files;
|
|
}
|
|
|
|
QFileInfoList l;
|
|
QDirIterator it(d->dirEntry.filePath(), nameFilters, filters);
|
|
while (it.hasNext()) {
|
|
it.next();
|
|
l.append(it.fileInfo());
|
|
}
|
|
QStringList ret;
|
|
d->sortFileList(sort, l, &ret, nullptr);
|
|
return ret;
|
|
}
|
|
|
|
/*!
|
|
Returns a list of QFileInfo objects for all the files and
|
|
directories in the directory, ordered according to the name
|
|
and attribute filters previously set with setNameFilters()
|
|
and setFilter(), and sorted according to the flags set with
|
|
setSorting().
|
|
|
|
The name filter, file attribute filter, and sorting specification
|
|
can be overridden using the \a nameFilters, \a filters, and \a sort
|
|
arguments.
|
|
|
|
Returns an empty list if the directory is unreadable, does not
|
|
exist, or if nothing matches the specification.
|
|
|
|
\sa entryList(), setNameFilters(), setSorting(), setFilter(), isReadable(), exists()
|
|
*/
|
|
QFileInfoList QDir::entryInfoList(const QStringList &nameFilters, Filters filters,
|
|
SortFlags sort) const
|
|
{
|
|
const QDirPrivate* d = d_ptr.constData();
|
|
|
|
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->fileInfos;
|
|
}
|
|
|
|
QFileInfoList l;
|
|
QDirIterator it(d->dirEntry.filePath(), nameFilters, filters);
|
|
while (it.hasNext()) {
|
|
it.next();
|
|
l.append(it.fileInfo());
|
|
}
|
|
QFileInfoList ret;
|
|
d->sortFileList(sort, l, nullptr, &ret);
|
|
return ret;
|
|
}
|
|
|
|
/*!
|
|
Creates a sub-directory called \a dirName.
|
|
|
|
Returns \c true on success; otherwise returns \c false.
|
|
|
|
If the directory already exists when this function is called, it will return false.
|
|
|
|
\sa rmdir()
|
|
*/
|
|
bool QDir::mkdir(const QString &dirName) const
|
|
{
|
|
const QDirPrivate* d = d_ptr.constData();
|
|
|
|
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);
|
|
}
|
|
|
|
/*!
|
|
Removes the directory specified by \a dirName.
|
|
|
|
The directory must be empty for rmdir() to succeed.
|
|
|
|
Returns \c true if successful; otherwise returns \c false.
|
|
|
|
\sa mkdir()
|
|
*/
|
|
bool QDir::rmdir(const QString &dirName) const
|
|
{
|
|
const QDirPrivate* d = d_ptr.constData();
|
|
|
|
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);
|
|
}
|
|
|
|
/*!
|
|
Creates the directory path \a dirPath.
|
|
|
|
The function will create all parent directories necessary to
|
|
create the directory.
|
|
|
|
Returns \c true if successful; otherwise returns \c false.
|
|
|
|
If the path already exists when this function is called, it will return true.
|
|
|
|
\sa rmpath()
|
|
*/
|
|
bool QDir::mkpath(const QString &dirPath) const
|
|
{
|
|
const QDirPrivate* d = d_ptr.constData();
|
|
|
|
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);
|
|
}
|
|
|
|
/*!
|
|
Removes the directory path \a dirPath.
|
|
|
|
The function will remove all parent directories in \a dirPath,
|
|
provided that they are empty. This is the opposite of
|
|
mkpath(dirPath).
|
|
|
|
Returns \c true if successful; otherwise returns \c false.
|
|
|
|
\sa mkpath()
|
|
*/
|
|
bool QDir::rmpath(const QString &dirPath) const
|
|
{
|
|
const QDirPrivate* d = d_ptr.constData();
|
|
|
|
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);
|
|
}
|
|
|
|
/*!
|
|
\since 5.0
|
|
Removes the directory, including all its contents.
|
|
|
|
Returns \c true if successful, otherwise false.
|
|
|
|
If a file or directory cannot be removed, removeRecursively() keeps going
|
|
and attempts to delete as many files and sub-directories as possible,
|
|
then returns \c false.
|
|
|
|
If the directory was already removed, the method returns \c true
|
|
(expected result already reached).
|
|
|
|
Note: this function is meant for removing a small application-internal
|
|
directory (such as a temporary directory), but not user-visible
|
|
directories. For user-visible operations, it is rather recommended
|
|
to report errors more precisely to the user, to offer solutions
|
|
in case of errors, to show progress during the deletion since it
|
|
could take several minutes, etc.
|
|
*/
|
|
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()) {
|
|
di.next();
|
|
const QFileInfo& fi = di.fileInfo();
|
|
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;
|
|
}
|
|
|
|
/*!
|
|
Returns \c true if the directory is readable \e and we can open files
|
|
by name; otherwise returns \c false.
|
|
|
|
\warning A false value from this function is not a guarantee that
|
|
files in the directory are not accessible.
|
|
|
|
\sa QFileInfo::isReadable()
|
|
*/
|
|
bool QDir::isReadable() const
|
|
{
|
|
const QDirPrivate* d = d_ptr.constData();
|
|
|
|
if (!d->fileEngine) {
|
|
if (!d->metaData.hasFlags(QFileSystemMetaData::UserReadPermission))
|
|
QFileSystemEngine::fillMetaData(d->dirEntry, d->metaData, QFileSystemMetaData::UserReadPermission);
|
|
|
|
return (d->metaData.permissions() & QFile::ReadUser) != 0;
|
|
}
|
|
|
|
const QAbstractFileEngine::FileFlags info =
|
|
d->fileEngine->fileFlags(QAbstractFileEngine::DirectoryType
|
|
| QAbstractFileEngine::PermsMask);
|
|
if (!(info & QAbstractFileEngine::DirectoryType))
|
|
return false;
|
|
return info & QAbstractFileEngine::ReadUserPerm;
|
|
}
|
|
|
|
/*!
|
|
\overload
|
|
|
|
Returns \c true if the directory exists; otherwise returns \c false.
|
|
(If a file with the same name is found this function will return false).
|
|
|
|
The overload of this function that accepts an argument is used to test
|
|
for the presence of files and directories within a directory.
|
|
|
|
\sa QFileInfo::exists(), QFile::exists()
|
|
*/
|
|
bool QDir::exists() const
|
|
{
|
|
return d_ptr->exists();
|
|
}
|
|
|
|
/*!
|
|
Returns \c true if the directory is the root directory; otherwise
|
|
returns \c false.
|
|
|
|
Note: If the directory is a symbolic link to the root directory
|
|
this function returns \c false. If you want to test for this use
|
|
canonicalPath(), e.g.
|
|
|
|
\snippet code/src_corelib_io_qdir.cpp 9
|
|
|
|
\sa root(), rootPath()
|
|
*/
|
|
bool QDir::isRoot() const
|
|
{
|
|
if (!d_ptr->fileEngine)
|
|
return d_ptr->dirEntry.isRoot();
|
|
return d_ptr->fileEngine->fileFlags(QAbstractFileEngine::FlagsMask) & QAbstractFileEngine::RootFlag;
|
|
}
|
|
|
|
/*!
|
|
\fn bool QDir::isAbsolute() const
|
|
|
|
Returns \c true if the directory's path is absolute; otherwise
|
|
returns \c false. See isAbsolutePath().
|
|
|
|
\sa isRelative(), makeAbsolute(), cleanPath()
|
|
*/
|
|
|
|
/*!
|
|
\fn bool QDir::isAbsolutePath(const QString &)
|
|
|
|
Returns \c true if \a path is absolute; returns \c false if it is
|
|
relative.
|
|
|
|
\sa isAbsolute(), isRelativePath(), makeAbsolute(), cleanPath()
|
|
*/
|
|
|
|
/*!
|
|
Returns \c true if the directory path is relative; otherwise returns
|
|
false. (Under Unix a path is relative if it does not start with a
|
|
"/").
|
|
|
|
\sa makeAbsolute(), isAbsolute(), isAbsolutePath(), cleanPath()
|
|
*/
|
|
bool QDir::isRelative() const
|
|
{
|
|
if (!d_ptr->fileEngine)
|
|
return d_ptr->dirEntry.isRelative();
|
|
return d_ptr->fileEngine->isRelativePath();
|
|
}
|
|
|
|
|
|
/*!
|
|
Converts the directory path to an absolute path. If it is already
|
|
absolute nothing happens. Returns \c true if the conversion
|
|
succeeded; otherwise returns \c false.
|
|
|
|
\sa isAbsolute(), isAbsolutePath(), isRelative(), cleanPath()
|
|
*/
|
|
bool QDir::makeAbsolute()
|
|
{
|
|
const QDirPrivate *d = d_ptr.constData();
|
|
QScopedPointer<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
|
|
d->resolveAbsoluteEntry();
|
|
dir.reset(new QDirPrivate(*d_ptr.constData()));
|
|
dir->setPath(d->absoluteDirEntry.filePath());
|
|
}
|
|
d_ptr = dir.take(); // actually detach
|
|
return true;
|
|
}
|
|
|
|
/*!
|
|
Returns \c true if directory \a dir and this directory have the same
|
|
path and their sort and filter settings are the same; otherwise
|
|
returns \c false.
|
|
|
|
Example:
|
|
|
|
\snippet code/src_corelib_io_qdir.cpp 10
|
|
*/
|
|
bool QDir::operator==(const QDir &dir) const
|
|
{
|
|
const QDirPrivate *d = d_ptr.constData();
|
|
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)
|
|
d->resolveAbsoluteEntry();
|
|
other->resolveAbsoluteEntry();
|
|
return d->absoluteDirEntry.filePath().compare(other->absoluteDirEntry.filePath(), sensitive) == 0;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/*!
|
|
Makes a copy of the \a dir object and assigns it to this QDir
|
|
object.
|
|
*/
|
|
QDir &QDir::operator=(const QDir &dir)
|
|
{
|
|
d_ptr = dir.d_ptr;
|
|
return *this;
|
|
}
|
|
|
|
#if QT_DEPRECATED_SINCE(5, 13)
|
|
/*!
|
|
\overload
|
|
\obsolete
|
|
|
|
Sets the directory path to the given \a path.
|
|
|
|
Use setPath() instead.
|
|
*/
|
|
QDir &QDir::operator=(const QString &path)
|
|
{
|
|
d_ptr->setPath(path);
|
|
return *this;
|
|
}
|
|
#endif
|
|
|
|
/*!
|
|
\fn void QDir::swap(QDir &other)
|
|
\since 5.0
|
|
|
|
Swaps this QDir instance with \a other. This function is very fast
|
|
and never fails.
|
|
*/
|
|
|
|
/*!
|
|
\fn bool QDir::operator!=(const QDir &dir) const
|
|
|
|
Returns \c true if directory \a dir and this directory have different
|
|
paths or different sort or filter settings; otherwise returns
|
|
false.
|
|
|
|
Example:
|
|
|
|
\snippet code/src_corelib_io_qdir.cpp 11
|
|
*/
|
|
|
|
/*!
|
|
Removes the file, \a fileName.
|
|
|
|
Returns \c true if the file is removed successfully; otherwise
|
|
returns \c false.
|
|
*/
|
|
bool QDir::remove(const QString &fileName)
|
|
{
|
|
if (fileName.isEmpty()) {
|
|
qWarning("QDir::remove: Empty or null file name");
|
|
return false;
|
|
}
|
|
return QFile::remove(filePath(fileName));
|
|
}
|
|
|
|
/*!
|
|
Renames a file or directory from \a oldName to \a newName, and returns
|
|
true if successful; otherwise returns \c false.
|
|
|
|
On most file systems, rename() fails only if \a oldName does not
|
|
exist, or if a file with the new name already exists.
|
|
However, there are also other reasons why rename() can
|
|
fail. For example, on at least one file system rename() fails if
|
|
\a newName points to an open file.
|
|
|
|
If \a oldName is a file (not a directory) that can't be renamed
|
|
right away, Qt will try to copy \a oldName to \a newName and remove
|
|
\a oldName.
|
|
|
|
\sa QFile::rename()
|
|
*/
|
|
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));
|
|
}
|
|
|
|
/*!
|
|
Returns \c true if the file called \a name exists; otherwise returns
|
|
false.
|
|
|
|
Unless \a name contains an absolute file path, the file name is assumed
|
|
to be relative to the directory itself, so this function is typically used
|
|
to check for the presence of files within a directory.
|
|
|
|
\sa QFileInfo::exists(), QFile::exists()
|
|
*/
|
|
bool QDir::exists(const QString &name) const
|
|
{
|
|
if (name.isEmpty()) {
|
|
qWarning("QDir::exists: Empty or null file name");
|
|
return false;
|
|
}
|
|
return QFile::exists(filePath(name));
|
|
}
|
|
|
|
/*!
|
|
Returns whether the directory is empty.
|
|
|
|
Equivalent to \c{count() == 0} with filters
|
|
\c{QDir::AllEntries | QDir::NoDotAndDotDot}, but faster as it just checks
|
|
whether the directory contains at least one entry.
|
|
|
|
\note Unless you set the \a filters flags to include \c{QDir::NoDotAndDotDot}
|
|
(as the default value does), no directory is empty.
|
|
|
|
\sa count(), entryList(), setFilter()
|
|
\since 5.9
|
|
*/
|
|
bool QDir::isEmpty(Filters filters) const
|
|
{
|
|
const auto d = d_ptr.constData();
|
|
QDirIterator it(d->dirEntry.filePath(), d->nameFilters, filters);
|
|
return !it.hasNext();
|
|
}
|
|
|
|
/*!
|
|
Returns a list of the root directories on this system.
|
|
|
|
On Windows this returns a list of QFileInfo objects containing "C:/",
|
|
"D:/", etc. On other operating systems, it returns a list containing
|
|
just one root directory (i.e. "/").
|
|
|
|
\sa root(), rootPath()
|
|
*/
|
|
QFileInfoList QDir::drives()
|
|
{
|
|
#ifdef QT_NO_FSFILEENGINE
|
|
return QFileInfoList();
|
|
#else
|
|
return QFSFileEngine::drives();
|
|
#endif
|
|
}
|
|
|
|
/*!
|
|
Returns the native directory separator: "/" under Unix
|
|
and "\\" under Windows.
|
|
|
|
You do not need to use this function to build file paths. If you
|
|
always use "/", Qt will translate your paths to conform to the
|
|
underlying operating system. If you want to display paths to the
|
|
user using their operating system's separator use
|
|
toNativeSeparators().
|
|
|
|
\sa listSeparator()
|
|
*/
|
|
QChar QDir::separator()
|
|
{
|
|
#if defined(Q_OS_WIN)
|
|
return QLatin1Char('\\');
|
|
#else
|
|
return QLatin1Char('/');
|
|
#endif
|
|
}
|
|
|
|
/*!
|
|
\fn QDir::listSeparator()
|
|
\since 5.6
|
|
|
|
Returns the native path list separator: ':' under Unix
|
|
and ';' under Windows.
|
|
|
|
\sa separator()
|
|
*/
|
|
|
|
/*!
|
|
Sets the application's current working directory to \a path.
|
|
Returns \c true if the directory was successfully changed; otherwise
|
|
returns \c false.
|
|
|
|
\sa current(), currentPath(), home(), root(), temp()
|
|
*/
|
|
bool QDir::setCurrent(const QString &path)
|
|
{
|
|
return QFileSystemEngine::setCurrentPath(QFileSystemEntry(path));
|
|
}
|
|
|
|
/*!
|
|
\fn QDir QDir::current()
|
|
|
|
Returns the application's current directory.
|
|
|
|
The directory is constructed using the absolute path of the current directory,
|
|
ensuring that its path() will be the same as its absolutePath().
|
|
|
|
\sa currentPath(), setCurrent(), home(), root(), temp()
|
|
*/
|
|
|
|
/*!
|
|
Returns the absolute path of the application's current directory. The
|
|
current directory is the last directory set with QDir::setCurrent() or, if
|
|
that was never called, the directory at which this application was started
|
|
at by the parent process.
|
|
|
|
\sa current(), setCurrent(), homePath(), rootPath(), tempPath(), QCoreApplication::applicationDirPath()
|
|
*/
|
|
QString QDir::currentPath()
|
|
{
|
|
return QFileSystemEngine::currentPath().filePath();
|
|
}
|
|
|
|
/*!
|
|
\fn QDir QDir::home()
|
|
|
|
Returns the user's home directory.
|
|
|
|
The directory is constructed using the absolute path of the home directory,
|
|
ensuring that its path() will be the same as its absolutePath().
|
|
|
|
See homePath() for details.
|
|
|
|
\sa drives(), current(), root(), temp()
|
|
*/
|
|
|
|
/*!
|
|
Returns the absolute path of the user's home directory.
|
|
|
|
Under Windows this function will return the directory of the
|
|
current user's profile. Typically, this is:
|
|
|
|
\snippet code/src_corelib_io_qdir.cpp 12
|
|
|
|
Use the toNativeSeparators() function to convert the separators to
|
|
the ones that are appropriate for the underlying operating system.
|
|
|
|
If the directory of the current user's profile does not exist or
|
|
cannot be retrieved, the following alternatives will be checked (in
|
|
the given order) until an existing and available path is found:
|
|
|
|
\list 1
|
|
\li The path specified by the \c USERPROFILE environment variable.
|
|
\li The path formed by concatenating the \c HOMEDRIVE and \c HOMEPATH
|
|
environment variables.
|
|
\li The path specified by the \c HOME environment variable.
|
|
\li The path returned by the rootPath() function (which uses the \c SystemDrive
|
|
environment variable)
|
|
\li The \c{C:/} directory.
|
|
\endlist
|
|
|
|
Under non-Windows operating systems the \c HOME environment
|
|
variable is used if it exists, otherwise the path returned by the
|
|
rootPath().
|
|
|
|
\sa home(), currentPath(), rootPath(), tempPath()
|
|
*/
|
|
QString QDir::homePath()
|
|
{
|
|
return QFileSystemEngine::homePath();
|
|
}
|
|
|
|
/*!
|
|
\fn QDir QDir::temp()
|
|
|
|
Returns the system's temporary directory.
|
|
|
|
The directory is constructed using the absolute canonical path of the temporary directory,
|
|
ensuring that its path() will be the same as its absolutePath().
|
|
|
|
See tempPath() for details.
|
|
|
|
\sa drives(), current(), home(), root()
|
|
*/
|
|
|
|
/*!
|
|
Returns the absolute canonical path of the system's temporary directory.
|
|
|
|
On Unix/Linux systems this is the path in the \c TMPDIR environment
|
|
variable or \c{/tmp} if \c TMPDIR is not defined. On Windows this is
|
|
usually the path in the \c TEMP or \c TMP environment
|
|
variable.
|
|
The path returned by this method doesn't end with a directory separator
|
|
unless it is the root directory (of a drive).
|
|
|
|
\sa temp(), currentPath(), homePath(), rootPath()
|
|
*/
|
|
QString QDir::tempPath()
|
|
{
|
|
return QFileSystemEngine::tempPath();
|
|
}
|
|
|
|
/*!
|
|
\fn QDir QDir::root()
|
|
|
|
Returns the root directory.
|
|
|
|
The directory is constructed using the absolute path of the root directory,
|
|
ensuring that its path() will be the same as its absolutePath().
|
|
|
|
See rootPath() for details.
|
|
|
|
\sa drives(), current(), home(), temp()
|
|
*/
|
|
|
|
/*!
|
|
Returns the absolute path of the root directory.
|
|
|
|
For Unix operating systems this returns "/". For Windows file
|
|
systems this normally returns "c:/".
|
|
|
|
\sa root(), drives(), currentPath(), homePath(), tempPath()
|
|
*/
|
|
QString QDir::rootPath()
|
|
{
|
|
return QFileSystemEngine::rootPath();
|
|
}
|
|
|
|
#if QT_CONFIG(regularexpression)
|
|
/*!
|
|
\overload
|
|
|
|
Returns \c true if the \a fileName matches any of the wildcard (glob)
|
|
patterns in the list of \a filters; otherwise returns \c false. The
|
|
matching is case insensitive.
|
|
|
|
\sa {QRegularExpression#Wildcard matching}{QRegularExpression Wildcard Matching},
|
|
entryList(), entryInfoList()
|
|
*/
|
|
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;
|
|
}
|
|
|
|
/*!
|
|
Returns \c true if the \a fileName matches the wildcard (glob)
|
|
pattern \a filter; otherwise returns \c false. The \a filter may
|
|
contain multiple patterns separated by spaces or semicolons.
|
|
The matching is case insensitive.
|
|
|
|
\sa {QRegularExpression#Wildcard matching}{QRegularExpression Wildcard Matching},
|
|
entryList(), entryInfoList()
|
|
*/
|
|
bool QDir::match(const QString &filter, const QString &fileName)
|
|
{
|
|
return match(nameFiltersFromString(filter), fileName);
|
|
}
|
|
#endif // QT_CONFIG(regularexpression)
|
|
|
|
/*!
|
|
\internal
|
|
Returns \a path with redundant directory separators removed,
|
|
and "."s and ".."s resolved (as far as possible).
|
|
|
|
This method is shared with QUrl, so it doesn't deal with QDir::separator(),
|
|
nor does it remove the trailing slash, if any.
|
|
*/
|
|
QString qt_normalizePathSegments(const QString &name, QDirPrivate::PathNormalizations flags, bool *ok)
|
|
{
|
|
const bool allowUncPaths = QDirPrivate::AllowUncPaths & flags;
|
|
const bool isRemote = QDirPrivate::RemotePath & flags;
|
|
const int len = name.length();
|
|
|
|
if (ok)
|
|
*ok = false;
|
|
|
|
if (len == 0)
|
|
return name;
|
|
|
|
int i = len - 1;
|
|
QVarLengthArray<char16_t> outVector(len);
|
|
int used = len;
|
|
char16_t *out = outVector.data();
|
|
const ushort *p = name.utf16();
|
|
const ushort *prefix = p;
|
|
int up = 0;
|
|
|
|
const int 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 ushort *p, int i) {
|
|
return i > 1 && p[i - 1] == '.' && p[i - 2] == '/';
|
|
};
|
|
auto isDotDot = [](const ushort *p, int 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] == '/') {
|
|
// Eventhough 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 (int 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())
|
|
return path;
|
|
QString name = path;
|
|
#if defined (Q_OS_WIN)
|
|
if (name.startsWith(QLatin1String("\\\\?\\")))
|
|
name.remove(0, 4);
|
|
#endif
|
|
|
|
QChar dir_separator = QDir::separator();
|
|
if (dir_separator != QLatin1Char('/'))
|
|
name.replace(dir_separator, QLatin1Char('/'));
|
|
|
|
QString ret = qt_normalizePathSegments(name, OSSupportsUncPaths ? QDirPrivate::AllowUncPaths : QDirPrivate::DefaultNormalization, ok);
|
|
|
|
// Strip away last slash except for root directories
|
|
if (ret.length() > 1 && ret.endsWith(QLatin1Char('/'))) {
|
|
#if defined (Q_OS_WIN)
|
|
if (!(ret.length() == 3 && ret.at(1) == QLatin1Char(':')))
|
|
#endif
|
|
ret.chop(1);
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
/*!
|
|
Returns \a path with directory separators normalized (that is, platform-native
|
|
separators converted to "/") and redundant ones removed, and "."s and ".."s
|
|
resolved (as far as possible).
|
|
|
|
Symbolic links are kept. This function does not return the
|
|
canonical path, but rather the simplest version of the input.
|
|
For example, "./local" becomes "local", "local/../bin" becomes
|
|
"bin" and "/local/usr/../bin" becomes "/local/bin".
|
|
|
|
\sa absolutePath(), canonicalPath()
|
|
*/
|
|
QString QDir::cleanPath(const QString &path)
|
|
{
|
|
return qt_cleanPath(path);
|
|
}
|
|
|
|
/*!
|
|
Returns \c true if \a path is relative; returns \c false if it is
|
|
absolute.
|
|
|
|
\sa isRelative(), isAbsolutePath(), makeAbsolute()
|
|
*/
|
|
bool QDir::isRelativePath(const QString &path)
|
|
{
|
|
return QFileInfo(path).isRelative();
|
|
}
|
|
|
|
/*!
|
|
Refreshes the directory information.
|
|
*/
|
|
void QDir::refresh() const
|
|
{
|
|
QDirPrivate *d = const_cast<QDir*>(this)->d_ptr.data();
|
|
d->metaData.clear();
|
|
d->initFileEngine();
|
|
d->clearFileLists();
|
|
}
|
|
|
|
/*!
|
|
\internal
|
|
*/
|
|
QDirPrivate* QDir::d_func()
|
|
{
|
|
return d_ptr.data();
|
|
}
|
|
|
|
/*!
|
|
\internal
|
|
|
|
Returns a list of name filters from the given \a nameFilter. (If
|
|
there is more than one filter, each pair of filters is separated
|
|
by a space or by a semicolon.)
|
|
*/
|
|
QStringList QDir::nameFiltersFromString(const QString &nameFilter)
|
|
{
|
|
return QDirPrivate::splitFilters(nameFilter);
|
|
}
|
|
|
|
/*!
|
|
\macro void Q_INIT_RESOURCE(name)
|
|
\relates QDir
|
|
|
|
Initializes the resources specified by the \c .qrc file with the
|
|
specified base \a name. Normally, when resources are built as part
|
|
of the application, the resources are loaded automatically at
|
|
startup. The Q_INIT_RESOURCE() macro is necessary on some platforms
|
|
for resources stored in a static library.
|
|
|
|
For example, if your application's resources are listed in a file
|
|
called \c myapp.qrc, you can ensure that the resources are
|
|
initialized at startup by adding this line to your \c main()
|
|
function:
|
|
|
|
\snippet code/src_corelib_io_qdir.cpp 13
|
|
|
|
If the file name contains characters that cannot be part of a valid C++ function name
|
|
(such as '-'), they have to be replaced by the underscore character ('_').
|
|
|
|
Note: This macro cannot be used in a namespace. It should be called from
|
|
main(). If that is not possible, the following workaround can be used
|
|
to init the resource \c myapp from the function \c{MyNamespace::myFunction}:
|
|
|
|
\snippet code/src_corelib_io_qdir.cpp 14
|
|
|
|
\sa Q_CLEANUP_RESOURCE(), {The Qt Resource System}
|
|
*/
|
|
|
|
/*!
|
|
\since 4.1
|
|
\macro void Q_CLEANUP_RESOURCE(name)
|
|
\relates QDir
|
|
|
|
Unloads the resources specified by the \c .qrc file with the base
|
|
name \a name.
|
|
|
|
Normally, Qt resources are unloaded automatically when the
|
|
application terminates, but if the resources are located in a
|
|
plugin that is being unloaded, call Q_CLEANUP_RESOURCE() to force
|
|
removal of your resources.
|
|
|
|
Note: This macro cannot be used in a namespace. Please see the
|
|
Q_INIT_RESOURCE documentation for a workaround.
|
|
|
|
Example:
|
|
|
|
\snippet code/src_corelib_io_qdir.cpp 15
|
|
|
|
\sa Q_INIT_RESOURCE(), {The Qt Resource System}
|
|
*/
|
|
|
|
|
|
#ifndef QT_NO_DEBUG_STREAM
|
|
QDebug operator<<(QDebug debug, QDir::Filters filters)
|
|
{
|
|
QDebugStateSaver save(debug);
|
|
debug.resetFormat();
|
|
QStringList flags;
|
|
if (filters == QDir::NoFilter) {
|
|
flags << QLatin1String("NoFilter");
|
|
} else {
|
|
if (filters & QDir::Dirs) flags << QLatin1String("Dirs");
|
|
if (filters & QDir::AllDirs) flags << QLatin1String("AllDirs");
|
|
if (filters & QDir::Files) flags << QLatin1String("Files");
|
|
if (filters & QDir::Drives) flags << QLatin1String("Drives");
|
|
if (filters & QDir::NoSymLinks) flags << QLatin1String("NoSymLinks");
|
|
if (filters & QDir::NoDot) flags << QLatin1String("NoDot");
|
|
if (filters & QDir::NoDotDot) flags << QLatin1String("NoDotDot");
|
|
if ((filters & QDir::AllEntries) == QDir::AllEntries) flags << QLatin1String("AllEntries");
|
|
if (filters & QDir::Readable) flags << QLatin1String("Readable");
|
|
if (filters & QDir::Writable) flags << QLatin1String("Writable");
|
|
if (filters & QDir::Executable) flags << QLatin1String("Executable");
|
|
if (filters & QDir::Modified) flags << QLatin1String("Modified");
|
|
if (filters & QDir::Hidden) flags << QLatin1String("Hidden");
|
|
if (filters & QDir::System) flags << QLatin1String("System");
|
|
if (filters & QDir::CaseSensitive) flags << QLatin1String("CaseSensitive");
|
|
}
|
|
debug.noquote() << "QDir::Filters(" << flags.join(QLatin1Char('|')) << ')';
|
|
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 & 3) == QDir::Name) type = QLatin1String("Name");
|
|
if ((sorting & 3) == QDir::Time) type = QLatin1String("Time");
|
|
if ((sorting & 3) == QDir::Size) type = QLatin1String("Size");
|
|
if ((sorting & 3) == QDir::Unsorted) type = QLatin1String("Unsorted");
|
|
|
|
QStringList flags;
|
|
if (sorting & QDir::DirsFirst) flags << QLatin1String("DirsFirst");
|
|
if (sorting & QDir::DirsLast) flags << QLatin1String("DirsLast");
|
|
if (sorting & QDir::IgnoreCase) flags << QLatin1String("IgnoreCase");
|
|
if (sorting & QDir::LocaleAware) flags << QLatin1String("LocaleAware");
|
|
if (sorting & QDir::Type) flags << QLatin1String("Type");
|
|
debug.noquote() << "QDir::SortFlags(" << type << '|' << flags.join(QLatin1Char('|')) << ')';
|
|
}
|
|
return debug;
|
|
}
|
|
|
|
QDebug operator<<(QDebug debug, const QDir &dir)
|
|
{
|
|
QDebugStateSaver save(debug);
|
|
debug.resetFormat();
|
|
debug << "QDir(" << dir.path() << ", nameFilters = {"
|
|
<< dir.nameFilters().join(QLatin1Char(','))
|
|
<< "}, "
|
|
<< dir.sorting()
|
|
<< ','
|
|
<< dir.filter()
|
|
<< ')';
|
|
return debug;
|
|
}
|
|
#endif // QT_NO_DEBUG_STREAM
|
|
|
|
/*!
|
|
\fn QDir::QDir(const std::filesystem::path &path)
|
|
\since 6.0
|
|
Constructs a QDir pointing to the given directory \a path. If path
|
|
is empty the program's working directory, ("."), is used.
|
|
|
|
\sa currentPath()
|
|
*/
|
|
/*!
|
|
\fn QDir::QDir(const std::filesystem::path &path,
|
|
const QString &nameFilter,
|
|
SortFlags sort,
|
|
Filters filters)
|
|
\since 6.0
|
|
|
|
Constructs a QDir with path \a path, that filters its entries by
|
|
name using \a nameFilter and by attributes using \a filters. It
|
|
also sorts the names using \a sort.
|
|
|
|
The default \a nameFilter is an empty string, which excludes
|
|
nothing; the default \a filters is \l AllEntries, which also
|
|
excludes nothing. The default \a sort is \l Name | \l IgnoreCase,
|
|
i.e. sort by name case-insensitively.
|
|
|
|
If \a path is empty, QDir uses "." (the current
|
|
directory). If \a nameFilter is an empty string, QDir uses the
|
|
name filter "*" (all files).
|
|
|
|
Note that \a path need not exist.
|
|
|
|
\sa exists(), setPath(), setNameFilters(), setFilter(), setSorting()
|
|
*/
|
|
/*!
|
|
\fn void QDir::setPath(const std::filesystem::path &path)
|
|
\since 6.0
|
|
\overload
|
|
*/
|
|
/*!
|
|
\fn void QDir::addSearchPath(const QString &prefix, const std::filesystem::path &path)
|
|
\since 6.0
|
|
\overload
|
|
*/
|
|
/*!
|
|
\fn std::filesystem::path QDir::filesystemPath() const
|
|
\since 6.0
|
|
Returns path() as \c{std::filesystem::path}.
|
|
\sa path()
|
|
*/
|
|
/*!
|
|
\fn std::filesystem::path QDir::filesystemAbsolutePath() const
|
|
\since 6.0
|
|
Returns absolutePath() as \c{std::filesystem::path}.
|
|
\sa absolutePath()
|
|
*/
|
|
/*!
|
|
\fn std::filesystem::path QDir::filesystemCanonicalPath() const
|
|
\since 6.0
|
|
Returns canonicalPath() as \c{std::filesystem::path}.
|
|
\sa canonicalPath()
|
|
*/
|
|
|
|
QT_END_NAMESPACE
|