| /**************************************************************************** |
| ** |
| ** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies). |
| ** All rights reserved. |
| ** Contact: Nokia Corporation (qt-info@nokia.com) |
| ** |
| ** This file is part of the QtCore module of the Qt Toolkit. |
| ** |
| ** $QT_BEGIN_LICENSE:LGPL$ |
| ** GNU Lesser General Public License Usage |
| ** This file may be used under the terms of the GNU Lesser General Public |
| ** License version 2.1 as published by the Free Software Foundation and |
| ** appearing in the file LICENSE.LGPL included in the packaging of this |
| ** file. Please review the following information to ensure the GNU Lesser |
| ** General Public License version 2.1 requirements will be met: |
| ** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. |
| ** |
| ** In addition, as a special exception, Nokia gives you certain additional |
| ** rights. These rights are described in the Nokia Qt LGPL Exception |
| ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. |
| ** |
| ** GNU General Public License Usage |
| ** Alternatively, this file may be used under the terms of the GNU General |
| ** Public License version 3.0 as published by the Free Software Foundation |
| ** and appearing in the file LICENSE.GPL included in the packaging of this |
| ** file. Please review the following information to ensure the GNU General |
| ** Public License version 3.0 requirements will be met: |
| ** http://www.gnu.org/copyleft/gpl.html. |
| ** |
| ** Other Usage |
| ** Alternatively, this file may be used in accordance with the terms and |
| ** conditions contained in a signed written agreement between you and Nokia. |
| ** |
| ** |
| ** |
| ** |
| ** |
| ** $QT_END_LICENSE$ |
| ** |
| ****************************************************************************/ |
| |
| #include "qplatformdefs.h" |
| #include "qdir.h" |
| #include "qabstractfileengine.h" |
| #ifndef QT_NO_DEBUG_STREAM |
| #include "qdebug.h" |
| #endif |
| #include "qdiriterator.h" |
| #include "qfsfileengine.h" |
| #include "qdatetime.h" |
| #include "qstring.h" |
| #include "qregexp.h" |
| #include "qvector.h" |
| #include "qalgorithms.h" |
| #include "qvarlengtharray.h" |
| |
| #ifdef QT_BUILD_CORE_LIB |
| # include "qresource.h" |
| # include "private/qcoreglobaldata_p.h" |
| #endif |
| |
| #include <stdlib.h> |
| |
| QT_BEGIN_NAMESPACE |
| |
| static QString driveSpec(const QString &path) |
| { |
| #if defined(Q_OS_WIN) || defined(Q_OS_SYMBIAN) |
| if (path.size() < 2) |
| return QString(); |
| char c = path.at(0).toAscii(); |
| if (c < 'a' && c > 'z' && c < 'A' && c > 'Z') |
| return QString(); |
| if (path.at(1).toAscii() != ':') |
| return QString(); |
| return path.mid(0, 2); |
| #else |
| Q_UNUSED(path); |
| return QString(); |
| #endif |
| } |
| |
| //************* QDirPrivate |
| class QDirPrivate |
| : public QSharedData |
| { |
| public: |
| QDirPrivate(const QString &path, |
| const QStringList &nameFilters_ = QStringList(), |
| QDir::SortFlags sort_ = QDir::SortFlags(QDir::Name | QDir::IgnoreCase), |
| QDir::Filters filters_ = QDir::AllEntries) |
| : QSharedData() |
| , nameFilters(nameFilters_) |
| , sort(sort_) |
| , filters(filters_) |
| #ifdef QT3_SUPPORT |
| , filterSepChar(0) |
| , matchAllDirs(false) |
| #endif |
| , fileListsInitialized(false) |
| { |
| 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(const QDirPrivate ©) |
| : QSharedData(copy) |
| , path(copy.path) |
| , nameFilters(copy.nameFilters) |
| , sort(copy.sort) |
| , filters(copy.filters) |
| #ifdef QT3_SUPPORT |
| , filterSepChar(copy.filterSepChar) |
| , matchAllDirs(copy.matchAllDirs) |
| #endif |
| , fileListsInitialized(false) |
| { |
| } |
| |
| bool exists() const |
| { |
| const QAbstractFileEngine::FileFlags info = |
| fileEngine->fileFlags(QAbstractFileEngine::DirectoryType |
| | QAbstractFileEngine::ExistsFlag |
| | QAbstractFileEngine::Refresh); |
| if (!(info & QAbstractFileEngine::DirectoryType)) |
| return false; |
| return info & QAbstractFileEngine::ExistsFlag; |
| } |
| |
| void initFileEngine(); |
| void initFileLists() const; |
| |
| static void sortFileList(QDir::SortFlags, QFileInfoList &, QStringList *, QFileInfoList *); |
| |
| static inline QChar 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 splitFilters(const QString &nameFilter, QChar sep = 0) |
| { |
| if (sep == 0) |
| sep = getFilterSepChar(nameFilter); |
| QStringList ret = nameFilter.split(sep); |
| for (int i = 0; i < ret.count(); ++i) |
| ret[i] = ret[i].trimmed(); |
| return ret; |
| } |
| |
| inline void setPath(QString p) |
| { |
| if ((p.endsWith(QLatin1Char('/')) || p.endsWith(QLatin1Char('\\'))) |
| && p.length() > 1) { |
| #if defined(Q_OS_WIN) || defined(Q_OS_SYMBIAN) |
| if (!(p.length() == 3 && p.at(1) == QLatin1Char(':'))) |
| #endif |
| p.truncate(p.length() - 1); |
| } |
| |
| path = p; |
| initFileEngine(); |
| |
| // set the path to be the qt friendly version so then we can operate on it using just / |
| path = fileEngine->fileName(QAbstractFileEngine::DefaultName); |
| clearFileLists(); |
| } |
| |
| inline void clearFileLists() { |
| fileListsInitialized = false; |
| files.clear(); |
| fileInfos.clear(); |
| } |
| |
| QString path; |
| QStringList nameFilters; |
| QDir::SortFlags sort; |
| QDir::Filters filters; |
| |
| #ifdef QT3_SUPPORT |
| QChar filterSepChar; |
| bool matchAllDirs; |
| #endif |
| |
| QScopedPointer<QAbstractFileEngine> fileEngine; |
| |
| mutable bool fileListsInitialized; |
| mutable QStringList files; |
| mutable QFileInfoList fileInfos; |
| }; |
| |
| /* 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 &); |
| }; |
| |
| bool QDirSortItemComparator::operator()(const QDirSortItem &n1, const QDirSortItem &n2) |
| { |
| 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(); |
| |
| int r = 0; |
| int sortBy = (qt_cmp_si_sort_flags & QDir::SortByMask) |
| | (qt_cmp_si_sort_flags & QDir::Type); |
| |
| switch (sortBy) { |
| case QDir::Time: |
| r = f1->item.lastModified().secsTo(f2->item.lastModified()); |
| break; |
| case QDir::Size: |
| r = int(qBound<qint64>(-1, f2->item.size() - f1->item.size(), 1)); |
| 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 (r == 0) // Enforce an order - the order the items appear in the array |
| r = (&n1) - (&n2); |
| 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); |
| qSort(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 |
| { |
| if (!fileListsInitialized) { |
| QFileInfoList l; |
| QDirIterator it(path, nameFilters, filters); |
| while (it.hasNext()) { |
| it.next(); |
| l.append(it.fileInfo()); |
| } |
| sortFileList(sort, l, &files, &fileInfos); |
| fileListsInitialized = true; |
| } |
| } |
| |
| inline void QDirPrivate::initFileEngine() |
| { |
| fileEngine.reset(QAbstractFileEngine::create(path)); |
| } |
| |
| /*! |
| \class QDir |
| \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 doc/src/snippets/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 doc/src/snippets/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 doc/src/snippets/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 doc/src/snippets/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 \o QDir \o QString \o Return Value |
| \row \o current() \o currentPath() \o The application's working directory |
| \row \o home() \o homePath() \o The user's home directory |
| \row \o root() \o rootPath() \o The root directory |
| \row \o temp() \o tempPath() \o 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 doc/src/snippets/code/src_corelib_io_qdir.cpp 4 |
| |
| (We could also use the static convenience function |
| QFile::exists().) |
| |
| Traversing directories and reading a file: |
| |
| \snippet doc/src/snippets/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 doc/src/snippets/qdir-listfiles/main.cpp 0 |
| |
| \sa QFileInfo, QFile, QFileDialog, QApplication::applicationDirPath(), {Find Files Example} |
| */ |
| |
| /*! |
| 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 means |
| exclude 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(), setNameFilter(), 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->path; |
| } |
| |
| /*! |
| 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(); |
| QString ret = d->path; |
| if (QDir::isRelativePath(ret)) |
| ret = absoluteFilePath(QString::fromLatin1("")); |
| return cleanPath(ret); |
| } |
| |
| /*! |
| 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 doc/src/snippets/code/src_corelib_io_qdir.cpp 6 |
| |
| \sa path(), absolutePath(), exists(), cleanPath(), dirName(), |
| absoluteFilePath() |
| */ |
| QString QDir::canonicalPath() const |
| { |
| return cleanPath(d_ptr->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(); |
| int pos = d->path.lastIndexOf(QLatin1Char('/')); |
| if (pos == -1) |
| return d->path; |
| return d->path.mid(pos + 1); |
| } |
| |
| /*! |
| 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 |
| { |
| const QDirPrivate* d = d_ptr.constData(); |
| if (isAbsolutePath(fileName)) |
| return QString(fileName); |
| |
| QString ret = d->path; |
| if (!fileName.isEmpty()) { |
| if (!ret.isEmpty() && ret[(int)ret.length()-1] != QLatin1Char('/') && fileName[0] != QLatin1Char('/')) |
| ret += QLatin1Char('/'); |
| ret += fileName; |
| } |
| return ret; |
| } |
| |
| /*! |
| 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 |
| { |
| const QDirPrivate* d = d_ptr.constData(); |
| if (isAbsolutePath(fileName)) |
| return fileName; |
| |
| QString ret; |
| #ifndef QT_NO_FSFILEENGINE |
| if (isRelativePath(d->path)) //get pwd |
| ret = QFSFileEngine::currentPath(fileName); |
| #endif |
| if (!d->path.isEmpty() && d->path != QLatin1String(".")) { |
| if (!ret.isEmpty() && !ret.endsWith(QLatin1Char('/'))) |
| ret += QLatin1Char('/'); |
| ret += d->path; |
| } |
| if (!fileName.isEmpty()) { |
| if (!ret.isEmpty() && !ret.endsWith(QLatin1Char('/'))) |
| ret += QLatin1Char('/'); |
| ret += fileName; |
| } |
| return ret; |
| } |
| |
| /*! |
| Returns the path to \a fileName relative to the directory. |
| |
| \snippet doc/src/snippets/code/src_corelib_io_qdir.cpp 7 |
| |
| \sa absoluteFilePath() filePath() canonicalPath() |
| */ |
| QString QDir::relativeFilePath(const QString &fileName) const |
| { |
| QString dir = absolutePath(); |
| QString file = cleanPath(fileName); |
| |
| if (isRelativePath(file) || isRelativePath(dir)) |
| return file; |
| |
| QString dirDrive = driveSpec(dir); |
| QString fileDrive = driveSpec(file); |
| |
| bool fileDriveMissing = false; |
| if (fileDrive.isEmpty()) { |
| fileDrive = dirDrive; |
| fileDriveMissing = true; |
| } |
| |
| #ifdef Q_OS_WIN |
| if (fileDrive.toLower() != dirDrive.toLower() |
| || (file.startsWith(QLatin1String("//")) |
| && !dir.startsWith(QLatin1String("//")))) |
| #elif defined(Q_OS_SYMBIAN) |
| if (fileDrive.toLower() != dirDrive.toLower()) |
| #else |
| if (fileDrive != dirDrive) |
| #endif |
| return file; |
| |
| dir.remove(0, dirDrive.size()); |
| if (!fileDriveMissing) |
| file.remove(0, fileDrive.size()); |
| |
| QString result; |
| QStringList dirElts = dir.split(QLatin1Char('/'), QString::SkipEmptyParts); |
| QStringList fileElts = file.split(QLatin1Char('/'), QString::SkipEmptyParts); |
| |
| int i = 0; |
| while (i < dirElts.size() && i < fileElts.size() && |
| #if defined(Q_OS_WIN) || defined(Q_OS_SYMBIAN) |
| dirElts.at(i).toLower() == fileElts.at(i).toLower()) |
| #else |
| dirElts.at(i) == fileElts.at(i)) |
| #endif |
| ++i; |
| |
| for (int j = 0; j < dirElts.size() - i; ++j) |
| result += QLatin1String("../"); |
| |
| for (int j = i; j < fileElts.size(); ++j) { |
| result += fileElts.at(j); |
| if (j < fileElts.size() - 1) |
| result += QLatin1Char('/'); |
| } |
| |
| return result; |
| } |
| |
| /*! |
| \obsolete |
| |
| Use QDir::toNativeSeparators() instead. |
| */ |
| QString QDir::convertSeparators(const QString &pathName) |
| { |
| return toNativeSeparators(pathName); |
| } |
| |
| /*! |
| \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) |
| { |
| QString n(pathName); |
| #if defined(Q_FS_FAT) || defined(Q_OS_OS2EMX) || defined(Q_OS_SYMBIAN) |
| for (int i = 0; i < (int)n.length(); ++i) { |
| if (n[i] == QLatin1Char('/')) |
| n[i] = QLatin1Char('\\'); |
| } |
| #endif |
| return n; |
| } |
| |
| /*! |
| \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) |
| { |
| QString n(pathName); |
| #if defined(Q_FS_FAT) || defined(Q_OS_OS2EMX) || defined(Q_OS_SYMBIAN) |
| for (int i = 0; i < (int)n.length(); ++i) { |
| if (n[i] == QLatin1Char('\\')) |
| n[i] = QLatin1Char('/'); |
| } |
| #endif |
| return n; |
| } |
| |
| /*! |
| Changes the QDir's directory to \a dirName. |
| |
| Returns true if the new directory exists and is readable; |
| otherwise returns 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 = d->path; |
| if (isAbsolutePath(dirName)) { |
| newPath = cleanPath(dirName); |
| } else { |
| if (isRoot()) { |
| if (dirName == QLatin1String("..")) |
| return false; |
| } else { |
| newPath += QLatin1Char('/'); |
| } |
| |
| newPath += dirName; |
| if (dirName.indexOf(QLatin1Char('/')) >= 0 |
| || d->path == QLatin1String(".") |
| || dirName == QLatin1String("..")) { |
| newPath = cleanPath(newPath); |
| /* |
| 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 true if the new directory exists and is readable; |
| otherwise returns 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{QRegExp 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 doc/src/snippets/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; |
| } |
| |
| /*! |
| \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 |
| QResource::addSearchPath(path); |
| #else |
| Q_UNUSED(path) |
| #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 doc/src/snippets/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 DefaultFilter |
| \omitvalue TypeMask |
| \omitvalue All |
| \omitvalue RWEMask |
| \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 |
| \omitvalue DefaultSort |
| |
| 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(); |
| 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(); |
| 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; |
| #ifdef QT3_SUPPORT |
| if (d->matchAllDirs) |
| filters |= AllDirs; |
| #endif |
| if (sort == NoSort) |
| sort = d->sort; |
| |
| if (filters == d->filters && sort == d->sort && nameFilters == d->nameFilters) { |
| d->initFileLists(); |
| return d->files; |
| } |
| |
| QFileInfoList l; |
| QDirIterator it(d->path, nameFilters, filters); |
| while (it.hasNext()) { |
| it.next(); |
| l.append(it.fileInfo()); |
| } |
| QStringList ret; |
| d->sortFileList(sort, l, &ret, 0); |
| 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; |
| #ifdef QT3_SUPPORT |
| if (d->matchAllDirs) |
| filters |= AllDirs; |
| #endif |
| if (sort == NoSort) |
| sort = d->sort; |
| |
| if (filters == d->filters && sort == d->sort && nameFilters == d->nameFilters) { |
| d->initFileLists(); |
| return d->fileInfos; |
| } |
| |
| QFileInfoList l; |
| QDirIterator it(d->path, nameFilters, filters); |
| while (it.hasNext()) { |
| it.next(); |
| l.append(it.fileInfo()); |
| } |
| QFileInfoList ret; |
| d->sortFileList(sort, l, 0, &ret); |
| return ret; |
| } |
| |
| /*! |
| Creates a sub-directory called \a dirName. |
| |
| Returns true on success; otherwise returns 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(s)"); |
| return false; |
| } |
| |
| QString fn = filePath(dirName); |
| return d->fileEngine->mkdir(fn, false); |
| } |
| |
| /*! |
| Removes the directory specified by \a dirName. |
| |
| The directory must be empty for rmdir() to succeed. |
| |
| Returns true if successful; otherwise returns 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(s)"); |
| return false; |
| } |
| |
| QString fn = filePath(dirName); |
| 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 true if successful; otherwise returns false. |
| |
| \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(s)"); |
| return false; |
| } |
| |
| QString fn = filePath(dirPath); |
| 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 true if successful; otherwise returns 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(s)"); |
| return false; |
| } |
| |
| QString fn = filePath(dirPath); |
| return d->fileEngine->rmdir(fn, true); |
| } |
| |
| /*! |
| Returns true if the directory is readable \e and we can open files |
| by name; otherwise returns 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(); |
| |
| const QAbstractFileEngine::FileFlags info = |
| d->fileEngine->fileFlags(QAbstractFileEngine::DirectoryType |
| | QAbstractFileEngine::PermsMask); |
| if (!(info & QAbstractFileEngine::DirectoryType)) |
| return false; |
| return info & QAbstractFileEngine::ReadUserPerm; |
| } |
| |
| /*! |
| \overload |
| |
| Returns true if the directory exists; otherwise returns 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 true if the directory is the root directory; otherwise |
| returns false. |
| |
| Note: If the directory is a symbolic link to the root directory |
| this function returns false. If you want to test for this use |
| canonicalPath(), e.g. |
| |
| \snippet doc/src/snippets/code/src_corelib_io_qdir.cpp 9 |
| |
| \sa root(), rootPath() |
| */ |
| bool QDir::isRoot() const |
| { |
| return d_ptr->fileEngine->fileFlags(QAbstractFileEngine::FlagsMask) & QAbstractFileEngine::RootFlag; |
| } |
| |
| /*! |
| \fn bool QDir::isAbsolute() const |
| |
| Returns true if the directory's path is absolute; otherwise |
| returns false. See isAbsolutePath(). |
| |
| \sa isRelative() makeAbsolute() cleanPath() |
| */ |
| |
| /*! |
| \fn bool QDir::isAbsolutePath(const QString &) |
| |
| Returns true if \a path is absolute; returns false if it is |
| relative. |
| |
| \sa isAbsolute() isRelativePath() makeAbsolute() cleanPath() |
| */ |
| |
| /*! |
| Returns 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 |
| { |
| return d_ptr->fileEngine->isRelativePath(); |
| } |
| |
| |
| /*! |
| Converts the directory path to an absolute path. If it is already |
| absolute nothing happens. Returns true if the conversion |
| succeeded; otherwise returns false. |
| |
| \sa isAbsolute() isAbsolutePath() isRelative() cleanPath() |
| */ |
| bool QDir::makeAbsolute() // ### What do the return values signify? |
| { |
| QString absolutePath = d_ptr.constData()->fileEngine->fileName(QAbstractFileEngine::AbsoluteName); |
| if (QDir::isRelativePath(absolutePath)) |
| return false; |
| |
| QScopedPointer<QDirPrivate> dir(new QDirPrivate(*d_ptr.constData())); |
| dir->setPath(absolutePath); |
| |
| d_ptr = dir.take(); |
| |
| if (!(d_ptr->fileEngine->fileFlags(QAbstractFileEngine::TypesMask) & QAbstractFileEngine::DirectoryType)) |
| return false; |
| |
| return true; |
| } |
| |
| /*! |
| Returns true if directory \a dir and this directory have the same |
| path and their sort and filter settings are the same; otherwise |
| returns false. |
| |
| Example: |
| |
| \snippet doc/src/snippets/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; |
| if (d->fileEngine->caseSensitive() != other->fileEngine->caseSensitive()) |
| return false; |
| if (d->filters == other->filters |
| && d->sort == other->sort |
| && d->nameFilters == other->nameFilters) { |
| QString dir1 = absolutePath(), dir2 = dir.absolutePath(); |
| if (!other->fileEngine->caseSensitive()) |
| return (dir1.toLower() == dir2.toLower()); |
| |
| return (dir1 == dir2); |
| |
| } |
| 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; |
| } |
| |
| /*! |
| \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; |
| } |
| |
| /*! |
| \fn bool QDir::operator!=(const QDir &dir) const |
| |
| Returns true if directory \a dir and this directory have different |
| paths or different sort or filter settings; otherwise returns |
| false. |
| |
| Example: |
| |
| \snippet doc/src/snippets/code/src_corelib_io_qdir.cpp 11 |
| */ |
| |
| /*! |
| Removes the file, \a fileName. |
| |
| Returns true if the file is removed successfully; otherwise |
| returns 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 false. |
| |
| On most file systems, rename() fails only if \a oldName does not |
| exist, if \a newName and \a oldName are not on the same |
| partition 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. |
| */ |
| 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 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 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 (including |
| Mac OS X) 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(). |
| */ |
| QChar QDir::separator() |
| { |
| #if defined (Q_FS_FAT) || defined(Q_WS_WIN) || defined(Q_OS_SYMBIAN) |
| return QLatin1Char('\\'); |
| #elif defined(Q_OS_UNIX) |
| return QLatin1Char('/'); |
| #elif defined (Q_OS_MAC) |
| return QLatin1Char(':'); |
| #else |
| return QLatin1Char('/'); |
| #endif |
| } |
| |
| /*! |
| Sets the application's current working directory to \a path. |
| Returns true if the directory was successfully changed; otherwise |
| returns false. |
| |
| \sa current(), currentPath(), home(), root(), temp() |
| */ |
| bool QDir::setCurrent(const QString &path) |
| { |
| #ifdef QT_NO_FSFILEENGINE |
| Q_UNUSED(path); |
| return false; |
| #else |
| return QFSFileEngine::setCurrentPath(path); |
| #endif |
| } |
| |
| /*! |
| \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. |
| |
| \sa current(), setCurrent(), homePath(), rootPath(), tempPath() |
| */ |
| QString QDir::currentPath() |
| { |
| #ifdef QT_NO_FSFILEENGINE |
| return QString(); |
| #else |
| return QFSFileEngine::currentPath(); |
| #endif |
| } |
| |
| /*! |
| \fn QString QDir::currentDirPath() |
| Returns the absolute path of the application's current directory. |
| |
| Use currentPath() instead. |
| |
| \sa currentPath(), setCurrent() |
| */ |
| |
| /*! |
| \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 doc/src/snippets/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 |
| \o The path specified by the \c USERPROFILE environment variable. |
| \o The path formed by concatenating the \c HOMEDRIVE and \c HOMEPATH |
| environment variables. |
| \o The path specified by the \c HOME environment variable. |
| \o The path returned by the rootPath() function (which uses the \c SystemDrive |
| environment variable) |
| \o 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(). On Symbian always the same as the path returned by the rootPath(). |
| |
| \sa home(), currentPath(), rootPath(), tempPath() |
| */ |
| QString QDir::homePath() |
| { |
| #ifdef QT_NO_FSFILEENGINE |
| return QString(); |
| #else |
| return cleanPath(QFSFileEngine::homePath()); |
| #endif |
| } |
| |
| /*! |
| \fn QString QDir::homeDirPath() |
| |
| Returns the absolute path of the user's home directory. |
| |
| Use homePath() instead. |
| |
| \sa homePath() |
| */ |
| |
| /*! |
| \fn QDir QDir::temp() |
| |
| Returns the system's temporary directory. |
| |
| The directory is constructed using the absolute 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 path of the system's temporary directory. |
| |
| On Unix/Linux systems this is usually \c{/tmp}; on Windows this is |
| usually the path in the \c TEMP or \c TMP environment |
| variable. Whether a directory separator is added to the end or |
| not, depends on the operating system. |
| |
| \sa temp(), currentPath(), homePath(), rootPath() |
| */ |
| QString QDir::tempPath() |
| { |
| #ifdef QT_NO_FSFILEENGINE |
| return QString(); |
| #else |
| return cleanPath(QFSFileEngine::tempPath()); |
| #endif |
| } |
| |
| /*! |
| \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:/". On Symbian this typically returns |
| "c:/data", i.e. the same as native PathInfo::PhoneMemoryRootPath(). |
| |
| \sa root(), drives(), currentPath(), homePath(), tempPath() |
| */ |
| QString QDir::rootPath() |
| { |
| #ifdef QT_NO_FSFILEENGINE |
| return QString(); |
| #else |
| return QFSFileEngine::rootPath(); |
| #endif |
| } |
| |
| /*! |
| \fn QString QDir::rootDirPath() |
| |
| Returns the absolute path of the root directory. |
| |
| Use rootPath() instead. |
| |
| \sa rootPath() |
| */ |
| |
| #ifndef QT_NO_REGEXP |
| /*! |
| \overload |
| |
| Returns true if the \a fileName matches any of the wildcard (glob) |
| patterns in the list of \a filters; otherwise returns false. The |
| matching is case insensitive. |
| |
| \sa {QRegExp wildcard matching}, QRegExp::exactMatch() entryList() entryInfoList() |
| */ |
| bool QDir::match(const QStringList &filters, const QString &fileName) |
| { |
| for (QStringList::ConstIterator sit = filters.constBegin(); sit != filters.constEnd(); ++sit) { |
| QRegExp rx(*sit, Qt::CaseInsensitive, QRegExp::Wildcard); |
| if (rx.exactMatch(fileName)) |
| return true; |
| } |
| return false; |
| } |
| |
| /*! |
| Returns true if the \a fileName matches the wildcard (glob) |
| pattern \a filter; otherwise returns false. The \a filter may |
| contain multiple patterns separated by spaces or semicolons. |
| The matching is case insensitive. |
| |
| \sa {QRegExp wildcard matching}, QRegExp::exactMatch() entryList() entryInfoList() |
| */ |
| bool QDir::match(const QString &filter, const QString &fileName) |
| { |
| return match(nameFiltersFromString(filter), fileName); |
| } |
| #endif // QT_NO_REGEXP |
| |
| /*! |
| Removes all multiple directory separators "/" and resolves any |
| "."s or ".."s found in the path, \a path. |
| |
| 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) |
| { |
| if (path.isEmpty()) |
| return path; |
| QString name = path; |
| QChar dir_separator = separator(); |
| if (dir_separator != QLatin1Char('/')) |
| name.replace(dir_separator, QLatin1Char('/')); |
| |
| int used = 0, levels = 0; |
| const int len = name.length(); |
| QVarLengthArray<QChar> outVector(len); |
| QChar *out = outVector.data(); |
| |
| const QChar *p = name.unicode(); |
| for (int i = 0, last = -1, iwrite = 0; i < len; ++i) { |
| if (p[i] == QLatin1Char('/')) { |
| while (i < len-1 && p[i+1] == QLatin1Char('/')) { |
| #if defined(Q_OS_WIN) && !defined(Q_OS_WINCE) //allow unc paths |
| if (!i) |
| break; |
| #endif |
| i++; |
| } |
| bool eaten = false; |
| if (i < len - 1 && p[i+1] == QLatin1Char('.')) { |
| int dotcount = 1; |
| if (i < len - 2 && p[i+2] == QLatin1Char('.')) |
| dotcount++; |
| if (i == len - dotcount - 1) { |
| if (dotcount == 1) { |
| break; |
| } else if (levels) { |
| if (last == -1) { |
| for (int i2 = iwrite-1; i2 >= 0; i2--) { |
| if (out[i2] == QLatin1Char('/')) { |
| last = i2; |
| break; |
| } |
| } |
| } |
| used -= iwrite - last - 1; |
| break; |
| } |
| } else if (p[i+dotcount+1] == QLatin1Char('/')) { |
| if (dotcount == 2 && levels) { |
| if (last == -1 || iwrite - last == 1) { |
| for (int i2 = (last == -1) ? (iwrite-1) : (last-1); i2 >= 0; i2--) { |
| if (out[i2] == QLatin1Char('/')) { |
| eaten = true; |
| last = i2; |
| break; |
| } |
| } |
| } else { |
| eaten = true; |
| } |
| if (eaten) { |
| levels--; |
| used -= iwrite - last; |
| iwrite = last; |
| last = -1; |
| } |
| } else if (dotcount == 2 && i > 0 && p[i - 1] != QLatin1Char('.')) { |
| eaten = true; |
| used -= iwrite - qMax(0, last); |
| iwrite = qMax(0, last); |
| last = -1; |
| ++i; |
| } else if (dotcount == 1) { |
| eaten = true; |
| } |
| if (eaten) |
| i += dotcount; |
| } else { |
| levels++; |
| } |
| } else if (last != -1 && iwrite - last == 1) { |
| #if defined(Q_OS_WIN) || defined(Q_OS_SYMBIAN) |
| eaten = (iwrite > 2); |
| #else |
| eaten = true; |
| #endif |
| last = -1; |
| } else if (last != -1 && i == len-1) { |
| eaten = true; |
| } else { |
| levels++; |
| } |
| if (!eaten) |
| last = i - (i - iwrite); |
| else |
| continue; |
| } else if (!i && p[i] == QLatin1Char('.')) { |
| int dotcount = 1; |
| if (len >= 1 && p[1] == QLatin1Char('.')) |
| dotcount++; |
| if (len >= dotcount && p[dotcount] == QLatin1Char('/')) { |
| if (dotcount == 1) { |
| i++; |
| while (i+1 < len-1 && p[i+1] == QLatin1Char('/')) |
| i++; |
| continue; |
| } |
| } |
| } |
| out[iwrite++] = p[i]; |
| used++; |
| } |
| |
| QString ret = (used == len ? name : QString(out, used)); |
| // Strip away last slash except for root directories |
| if (ret.length() > 1 && ret.endsWith(QLatin1Char('/'))) { |
| #if defined (Q_OS_WIN) || defined (Q_OS_SYMBIAN) |
| if (!(ret.length() == 3 && ret.at(1) == QLatin1Char(':'))) |
| #endif |
| ret.chop(1); |
| } |
| |
| return ret; |
| } |
| |
| /*! |
| Returns true if \a path is relative; returns 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->initFileEngine(); |
| d->clearFileLists(); |
| } |
| |
| /*! |
| \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, Qt 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 doc/src/snippets/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 doc/src/snippets/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 doc/src/snippets/code/src_corelib_io_qdir.cpp 15 |
| |
| \sa Q_INIT_RESOURCE(), {The Qt Resource System} |
| */ |
| |
| #ifdef QT3_SUPPORT |
| |
| /*! |
| \fn bool QDir::matchAllDirs() const |
| |
| Use filter() & AllDirs instead. |
| */ |
| bool QDir::matchAllDirs() const |
| { |
| const QDirPrivate* d = d_ptr.constData(); |
| return d->matchAllDirs; |
| } |
| |
| |
| /*! |
| \fn void QDir::setMatchAllDirs(bool on) |
| |
| Use setFilter() instead. |
| */ |
| void QDir::setMatchAllDirs(bool on) |
| { |
| QDirPrivate* d = d_ptr.data(); |
| d->initFileEngine(); |
| d->clearFileLists(); |
| |
| d->matchAllDirs = on; |
| } |
| |
| /*! |
| Use nameFilters() instead. |
| */ |
| QString QDir::nameFilter() const |
| { |
| const QDirPrivate* d = d_ptr.constData(); |
| return nameFilters().join(QString(d->filterSepChar)); |
| } |
| |
| /*! |
| Use setNameFilters() instead. |
| |
| The \a nameFilter is a wildcard (globbing) filter that understands |
| "*" and "?" wildcards. (See \l{QRegExp wildcard matching}.) You may |
| specify several filter entries, each separated by spaces or by |
| semicolons. |
| |
| For example, if you want entryList() and entryInfoList() to list |
| all files ending with either ".cpp" or ".h", you would use either |
| dir.setNameFilters("*.cpp *.h") or dir.setNameFilters("*.cpp;*.h"). |
| |
| \oldcode |
| QString filter = "*.cpp *.cxx *.cc"; |
| dir.setNameFilter(filter); |
| \newcode |
| QString filter = "*.cpp *.cxx *.cc"; |
| dir.setNameFilters(filter.split(' ')); |
| \endcode |
| */ |
| void QDir::setNameFilter(const QString &nameFilter) |
| { |
| QDirPrivate* d = d_ptr.data(); |
| d->initFileEngine(); |
| d->clearFileLists(); |
| |
| d->filterSepChar = QDirPrivate::getFilterSepChar(nameFilter); |
| d->nameFilters = QDirPrivate::splitFilters(nameFilter, d->filterSepChar); |
| } |
| |
| /*! |
| \fn QString QDir::absPath() const |
| |
| Use absolutePath() instead. |
| */ |
| |
| /*! |
| \fn QString QDir::absFilePath(const QString &fileName, bool acceptAbsPath) const |
| |
| Use absoluteFilePath(\a fileName) instead. |
| |
| The \a acceptAbsPath parameter is ignored. |
| */ |
| |
| /*! |
| \fn bool QDir::mkdir(const QString &dirName, bool acceptAbsPath) const |
| |
| Use mkdir(\a dirName) instead. |
| |
| The \a acceptAbsPath parameter is ignored. |
| */ |
| |
| /*! |
| \fn bool QDir::rmdir(const QString &dirName, bool acceptAbsPath) const |
| |
| Use rmdir(\a dirName) instead. |
| |
| The \a acceptAbsPath parameter is ignored. |
| */ |
| |
| /*! |
| \fn QStringList QDir::entryList(const QString &nameFilter, Filters filters, |
| SortFlags sort) const |
| \overload |
| |
| Use the overload that takes a name filter string list as first |
| argument instead of a combination of attribute filter flags. |
| */ |
| |
| /*! |
| \fn QFileInfoList QDir::entryInfoList(const QString &nameFilter, Filters filters, |
| SortFlags sort) const |
| \overload |
| |
| Use the overload that takes a name filter string list as first |
| argument instead of a combination of attribute filter flags. |
| */ |
| |
| /*! |
| \fn void QDir::convertToAbs() |
| |
| Use makeAbsolute() instead. |
| */ |
| |
| /*! |
| \fn QString QDir::cleanDirPath(const QString &name) |
| |
| Use cleanPath() instead. |
| */ |
| |
| /*! |
| \typedef QDir::FilterSpec |
| |
| Use QDir::Filters instead. |
| */ |
| |
| /*! |
| \typedef QDir::SortSpec |
| |
| Use QDir::SortFlags instead. |
| */ |
| #endif // QT3_SUPPORT |
| |
| #ifndef QT_NO_DEBUG_STREAM |
| QDebug operator<<(QDebug debug, QDir::Filters filters) |
| { |
| 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::NoDotAndDotDot) flags << QLatin1String("NoDotAndDotDot"); // ### Qt5: remove (because NoDotAndDotDot=NoDot|NoDotDot) |
| 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 << "QDir::Filters(" << qPrintable(flags.join(QLatin1String("|"))) << ')'; |
| return debug; |
| } |
| |
| static QDebug operator<<(QDebug debug, QDir::SortFlags sorting) |
| { |
| 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 << "QDir::SortFlags(" << qPrintable(type) |
| << '|' |
| << qPrintable(flags.join(QLatin1String("|"))) << ')'; |
| } |
| return debug; |
| } |
| |
| QDebug operator<<(QDebug debug, const QDir &dir) |
| { |
| debug.maybeSpace() << "QDir(" << dir.path() |
| << ", nameFilters = {" |
| << qPrintable(dir.nameFilters().join(QLatin1String(","))) |
| << "}, " |
| << dir.sorting() |
| << ',' |
| << dir.filter() |
| << ')'; |
| return debug.space(); |
| } |
| #endif // QT_NO_DEBUG_STREAM |
| |
| QT_END_NAMESPACE |