1 /****************************************************************************

     2 **

     3 ** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).

     4 ** All rights reserved.

     5 ** Contact: Nokia Corporation (qt-info@nokia.com)

     6 **

     7 ** This file is part of the QtCore module of the Qt Toolkit.

     8 **

     9 ** $QT_BEGIN_LICENSE:LGPL$

    10 ** No Commercial Usage

    11 ** This file contains pre-release code and may not be distributed.

    12 ** You may use this file in accordance with the terms and conditions

    13 ** contained in the Technology Preview License Agreement accompanying

    14 ** this package.

    15 **

    16 ** GNU Lesser General Public License Usage

    17 ** Alternatively, this file may be used under the terms of the GNU Lesser

    18 ** General Public License version 2.1 as published by the Free Software

    19 ** Foundation and appearing in the file LICENSE.LGPL included in the

    20 ** packaging of this file.  Please review the following information to

    21 ** ensure the GNU Lesser General Public License version 2.1 requirements

    22 ** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.

    23 **

    24 ** In addition, as a special exception, Nokia gives you certain additional

    25 ** rights.  These rights are described in the Nokia Qt LGPL Exception

    26 ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.

    27 **

    28 ** If you have questions regarding the use of this file, please contact

    29 ** Nokia at qt-info@nokia.com.

    30 **

    31 **

    32 **

    33 **

    34 **

    35 **

    36 **

    37 **

    38 ** $QT_END_LICENSE$

    39 **

    40 ****************************************************************************/

    41 

    42 #include "qplatformdefs.h"

    43 #include "qdir.h"

    44 #include "qabstractfileengine.h"

    45 #ifndef QT_NO_DEBUG_STREAM

    46 #include "qdebug.h"

    47 #endif

    48 #include "qdiriterator.h"

    49 #include "qfsfileengine.h"

    50 #include "qdatetime.h"

    51 #include "qstring.h"

    52 #include "qregexp.h"

    53 #include "qvector.h"

    54 #include "qalgorithms.h"

    55 #ifdef QT_BUILD_CORE_LIB

    56 # include "qresource.h"

    57 #endif

    58 

    59 #include "qvarlengtharray.h"

    60 

    61 #include "private/qcoreglobaldata_p.h"

    62 #include <stdlib.h>

    63 

    64 QT_BEGIN_NAMESPACE

    65 

    66 static QString driveSpec(const QString &path)

    67 {

    68 #if defined(Q_OS_WIN) || defined(Q_OS_SYMBIAN)

    69     if (path.size() < 2)

    70         return QString();

    71     char c = path.at(0).toAscii();

    72     if (c < 'a' && c > 'z' && c < 'A' && c > 'Z')

    73         return QString();

    74     if (path.at(1).toAscii() != ':')

    75         return QString();

    76     return path.mid(0, 2);

    77 #else

    78     Q_UNUSED(path);

    79     return QString();

    80 #endif

    81 }

    82 

    83 //************* QDirPrivate

    84 class QDirPrivate

    85 {

    86     QDir *q_ptr;

    87     Q_DECLARE_PUBLIC(QDir)

    88 

    89     friend struct QScopedPointerDeleter<QDirPrivate>;

    90 protected:

    91     QDirPrivate(QDir*, const QDir *copy=0);

    92     ~QDirPrivate();

    93 

    94     QString initFileEngine(const QString &file);

    95 

    96     void updateFileLists() const;

    97     void sortFileList(QDir::SortFlags, QFileInfoList &, QStringList *, QFileInfoList *) const;

    98 

    99 private:

   100 #ifdef QT3_SUPPORT

   101     QChar filterSepChar;

   102     bool matchAllDirs;

   103 #endif

   104     static inline QChar getFilterSepChar(const QString &nameFilter)

   105     {

   106         QChar sep(QLatin1Char(';'));

   107         int i = nameFilter.indexOf(sep, 0);

   108         if (i == -1 && nameFilter.indexOf(QLatin1Char(' '), 0) != -1)

   109             sep = QChar(QLatin1Char(' '));

   110         return sep;

   111     }

   112     static inline QStringList splitFilters(const QString &nameFilter, QChar sep=0) {

   113         if(sep == 0)

   114             sep = getFilterSepChar(nameFilter);

   115         QStringList ret = nameFilter.split(sep);

   116         for(int i = 0; i < ret.count(); i++)

   117             ret[i] = ret[i].trimmed();

   118         return ret;

   119     }

   120 

   121     struct Data {

   122         inline Data()

   123             : ref(1), fileEngine(0)

   124         { clear(); }

   125         inline Data(const Data &copy)

   126             : ref(1), path(copy.path), nameFilters(copy.nameFilters), sort(copy.sort),

   127               filters(copy.filters), fileEngine(0)

   128         { clear(); }

   129         inline ~Data()

   130         { delete fileEngine; }

   131 

   132         inline void clear() {

   133             listsDirty = 1;

   134         }

   135         mutable QAtomicInt ref;

   136 

   137         QString path;

   138         QStringList nameFilters;

   139         QDir::SortFlags sort;

   140         QDir::Filters filters;

   141 

   142         mutable QAbstractFileEngine *fileEngine;

   143 

   144         mutable uint listsDirty : 1;

   145         mutable QStringList files;

   146         mutable QFileInfoList fileInfos;

   147     } *data;

   148     inline void setPath(const QString &p)

   149     {

   150         detach(false);

   151         QString path = p;

   152         if ((path.endsWith(QLatin1Char('/')) || path.endsWith(QLatin1Char('\\')))

   153                 && path.length() > 1) {

   154 #if defined(Q_OS_WIN) || defined(Q_OS_SYMBIAN)

   155             if (!(path.length() == 3 && path.at(1) == QLatin1Char(':')))

   156 #endif

   157                 path.truncate(path.length() - 1);

   158         }

   159         if(!data->fileEngine || !QDir::isRelativePath(path))

   160             path = initFileEngine(path);

   161         data->fileEngine->setFileName(path);

   162         // set the path to be the qt friendly version so then we can operate on it using just /

   163         data->path = data->fileEngine->fileName(QAbstractFileEngine::DefaultName);

   164         data->clear();

   165     }

   166     inline void reset() {

   167         detach();

   168         data->clear();

   169     }

   170     void detach(bool createFileEngine = true);

   171 };

   172 

   173 QDirPrivate::QDirPrivate(QDir *qq, const QDir *copy) : q_ptr(qq)

   174 #ifdef QT3_SUPPORT

   175                                                      , filterSepChar(0)

   176                                                      , matchAllDirs(false)

   177 #endif

   178 {

   179     if(copy) {

   180         copy->d_func()->data->ref.ref();

   181         data = copy->d_func()->data;

   182     } else {

   183         data = new QDirPrivate::Data;

   184         data->clear();

   185     }

   186 }

   187 

   188 QDirPrivate::~QDirPrivate()

   189 {

   190     if (!data->ref.deref())

   191         delete data;

   192     data = 0;

   193     q_ptr = 0;

   194 }

   195 

   196 /* For sorting */

   197 struct QDirSortItem {

   198     mutable QString filename_cache;

   199     mutable QString suffix_cache;

   200     QFileInfo item;

   201 };

   202 

   203 

   204 class QDirSortItemComparator {

   205     int qt_cmp_si_sort_flags;

   206 public:

   207     QDirSortItemComparator(int flags) : qt_cmp_si_sort_flags(flags) {}

   208     bool operator()(const QDirSortItem &, const QDirSortItem &);

   209 };

   210 

   211 bool QDirSortItemComparator::operator()(const QDirSortItem &n1, const QDirSortItem &n2)

   212 {

   213     const QDirSortItem* f1 = &n1;

   214     const QDirSortItem* f2 = &n2;

   215 

   216     if ((qt_cmp_si_sort_flags & QDir::DirsFirst) && (f1->item.isDir() != f2->item.isDir()))

   217         return f1->item.isDir();

   218     if ((qt_cmp_si_sort_flags & QDir::DirsLast) && (f1->item.isDir() != f2->item.isDir()))

   219         return !f1->item.isDir();

   220 

   221     int r = 0;

   222     int sortBy = (qt_cmp_si_sort_flags & QDir::SortByMask)

   223                  | (qt_cmp_si_sort_flags & QDir::Type);

   224 

   225     switch (sortBy) {

   226       case QDir::Time:

   227         r = f1->item.lastModified().secsTo(f2->item.lastModified());

   228         break;

   229       case QDir::Size:

   230           r = int(qBound<qint64>(-1, f2->item.size() - f1->item.size(), 1));

   231         break;

   232       case QDir::Type:

   233       {

   234         bool ic = qt_cmp_si_sort_flags & QDir::IgnoreCase;

   235 

   236         if (f1->suffix_cache.isNull())

   237             f1->suffix_cache = ic ? f1->item.suffix().toLower()

   238                                : f1->item.suffix();

   239         if (f2->suffix_cache.isNull())

   240             f2->suffix_cache = ic ? f2->item.suffix().toLower()

   241                                : f2->item.suffix();

   242 

   243 	r = qt_cmp_si_sort_flags & QDir::LocaleAware

   244             ? f1->suffix_cache.localeAwareCompare(f2->suffix_cache)

   245             : f1->suffix_cache.compare(f2->suffix_cache);

   246       }

   247         break;

   248       default:

   249         ;

   250     }

   251 

   252     if (r == 0 && sortBy != QDir::Unsorted) {

   253         // Still not sorted - sort by name

   254         bool ic = qt_cmp_si_sort_flags & QDir::IgnoreCase;

   255 

   256         if (f1->filename_cache.isNull())

   257             f1->filename_cache = ic ? f1->item.fileName().toLower()

   258                                     : f1->item.fileName();

   259         if (f2->filename_cache.isNull())

   260             f2->filename_cache = ic ? f2->item.fileName().toLower()

   261                                     : f2->item.fileName();

   262 

   263 	r = qt_cmp_si_sort_flags & QDir::LocaleAware

   264             ? f1->filename_cache.localeAwareCompare(f2->filename_cache)

   265             : f1->filename_cache.compare(f2->filename_cache);

   266     }

   267     if (r == 0) // Enforce an order - the order the items appear in the array

   268         r = (&n1) - (&n2);

   269     if (qt_cmp_si_sort_flags & QDir::Reversed)

   270         return r > 0;

   271     return r < 0;

   272 }

   273 

   274 inline void QDirPrivate::sortFileList(QDir::SortFlags sort, QFileInfoList &l,

   275                                       QStringList *names, QFileInfoList *infos) const

   276 {

   277     if(names)

   278         names->clear();

   279     if(infos)

   280         infos->clear();

   281     int n = l.size();

   282     if(n > 0) {

   283         if (n == 1 || (sort & QDir::SortByMask) == QDir::Unsorted) {

   284             if(infos)

   285                 *infos = l;

   286             if(names) {

   287                 for (int i = 0; i < n; ++i)

   288                     names->append(l.at(i).fileName());

   289             }

   290         } else {

   291             QScopedArrayPointer<QDirSortItem> si(new QDirSortItem[n]);

   292             for (int i = 0; i < n; ++i)

   293                 si[i].item = l.at(i);

   294             qSort(si.data(), si.data()+n, QDirSortItemComparator(sort));

   295             // put them back in the list(s)

   296             if(infos) {

   297                 for (int i = 0; i < n; ++i)

   298                     infos->append(si[i].item);

   299             }

   300             if(names) {

   301                 for (int i = 0; i < n; ++i)

   302                     names->append(si[i].item.fileName());

   303             }

   304         }

   305     }

   306 }

   307 

   308 inline void QDirPrivate::updateFileLists() const

   309 {

   310     if(data->listsDirty) {

   311         QFileInfoList l;

   312         QDirIterator it(data->path, data->nameFilters, data->filters);

   313         while (it.hasNext()) {

   314             it.next();

   315             l.append(it.fileInfo());

   316         }

   317         sortFileList(data->sort, l, &data->files, &data->fileInfos);

   318         data->listsDirty = 0;

   319     }

   320 }

   321 

   322 QString QDirPrivate::initFileEngine(const QString &path)

   323 {

   324     detach(false);

   325     delete data->fileEngine;

   326     data->fileEngine = 0;

   327     data->clear();

   328     data->fileEngine = QAbstractFileEngine::create(path);

   329     return data->fileEngine->fileName(QAbstractFileEngine::DefaultName);

   330 }

   331 

   332 void QDirPrivate::detach(bool createFileEngine)

   333 {

   334     qAtomicDetach(data);

   335     if (createFileEngine) {

   336         QAbstractFileEngine *newFileEngine = QAbstractFileEngine::create(data->path);

   337         delete data->fileEngine;

   338         data->fileEngine = newFileEngine;

   339     }

   340 }

   341 

   342 /*!

   343     \class QDir

   344     \brief The QDir class provides access to directory structures and their contents.

   345 

   346     \ingroup io

   347     \ingroup shared

   348     \reentrant

   349 

   350 

   351     A QDir is used to manipulate path names, access information

   352     regarding paths and files, and manipulate the underlying file

   353     system. It can also be used to access Qt's \l{resource system}.

   354 

   355     Qt uses "/" as a universal directory separator in the same way

   356     that "/" is used as a path separator in URLs. If you always use

   357     "/" as a directory separator, Qt will translate your paths to

   358     conform to the underlying operating system.

   359 

   360     A QDir can point to a file using either a relative or an absolute

   361     path. Absolute paths begin with the directory separator

   362     (optionally preceded by a drive specification under Windows).

   363     Relative file names begin with a directory name or a file name and

   364     specify a path relative to the current directory.

   365 

   366     Examples of absolute paths:

   367 

   368     \snippet doc/src/snippets/code/src_corelib_io_qdir.cpp 0

   369 

   370     On Windows, the second example above will be translated to

   371     \c{C:\Documents and Settings} when used to access files.

   372 

   373     Examples of relative paths:

   374 

   375     \snippet doc/src/snippets/code/src_corelib_io_qdir.cpp 1

   376 

   377     You can use the isRelative() or isAbsolute() functions to check if

   378     a QDir is using a relative or an absolute file path. Call

   379     makeAbsolute() to convert a relative QDir to an absolute one.

   380 

   381     \section1 Navigation and Directory Operations

   382 

   383     A directory's path can be obtained with the path() function, and

   384     a new path set with the setPath() function. The absolute path to

   385     a directory is found by calling absolutePath().

   386 

   387     The name of a directory is found using the dirName() function. This

   388     typically returns the last element in the absolute path that specifies

   389     the location of the directory. However, it can also return "." if

   390     the QDir represents the current directory.

   391 

   392     \snippet doc/src/snippets/code/src_corelib_io_qdir.cpp 2

   393 

   394     The path for a directory can also be changed with the cd() and cdUp()

   395     functions, both of which operate like familiar shell commands.

   396     When cd() is called with the name of an existing directory, the QDir

   397     object changes directory so that it represents that directory instead.

   398     The cdUp() function changes the directory of the QDir object so that

   399     it refers to its parent directory; i.e. cd("..") is equivalent to

   400     cdUp().

   401 

   402     Directories can be created with mkdir(), renamed with rename(), and

   403     removed with rmdir().

   404 

   405     You can test for the presence of a directory with a given name by

   406     using exists(), and the properties of a directory can be tested with

   407     isReadable(), isAbsolute(), isRelative(), and isRoot().

   408 

   409     The refresh() function re-reads the directory's data from disk.

   410 

   411     \section1 Files and Directory Contents

   412 

   413     Directories contain a number of entries, representing files,

   414     directories, and symbolic links. The number of entries in a

   415     directory is returned by count().

   416     A string list of the names of all the entries in a directory can be

   417     obtained with entryList(). If you need information about each

   418     entry, use entryInfoList() to obtain a list of QFileInfo objects.

   419 

   420     Paths to files and directories within a directory can be

   421     constructed using filePath() and absoluteFilePath().

   422     The filePath() function returns a path to the specified file

   423     or directory relative to the path of the QDir object;

   424     absoluteFilePath() returns an absolute path to the specified

   425     file or directory. Neither of these functions checks for the

   426     existence of files or directory; they only construct paths.

   427 

   428     \snippet doc/src/snippets/code/src_corelib_io_qdir.cpp 3

   429 

   430     Files can be removed by using the remove() function. Directories

   431     cannot be removed in the same way as files; use rmdir() to remove

   432     them instead.

   433 

   434     It is possible to reduce the number of entries returned by

   435     entryList() and entryInfoList() by applying filters to a QDir object.

   436     You can apply a name filter to specify a pattern with wildcards that

   437     file names need to match, an attribute filter that selects properties

   438     of entries and can distinguish between files and directories, and a

   439     sort order.

   440 

   441     Name filters are lists of strings that are passed to setNameFilters().

   442     Attribute filters consist of a bitwise OR combination of Filters, and

   443     these are specified when calling setFilter().

   444     The sort order is specified using setSorting() with a bitwise OR

   445     combination of SortFlags.

   446 

   447     You can test to see if a filename matches a filter using the match()

   448     function.

   449 

   450     Filter and sort order flags may also be specified when calling

   451     entryList() and entryInfoList() in order to override previously defined

   452     behavior.

   453 

   454     \section1 The Current Directory and Other Special Paths

   455 

   456     Access to some common directories is provided with a number of static

   457     functions that return QDir objects. There are also corresponding functions

   458     for these that return strings:

   459 

   460     \table

   461     \header \o QDir      \o QString         \o Return Value

   462     \row    \o current() \o currentPath()   \o The application's working directory

   463     \row    \o home()    \o homePath()      \o The user's home directory

   464     \row    \o root()    \o rootPath()      \o The root directory

   465     \row    \o temp()    \o tempPath()      \o The system's temporary directory

   466     \endtable

   467 

   468     The setCurrent() static function can also be used to set the application's

   469     working directory.

   470 

   471     If you want to find the directory containing the application's executable,

   472     see \l{QCoreApplication::applicationDirPath()}.

   473 

   474     The drives() static function provides a list of root directories for each

   475     device that contains a filing system. On Unix systems this returns a list

   476     containing a single root directory "/"; on Windows the list will usually

   477     contain \c{C:/}, and possibly other drive letters such as \c{D:/}, depending

   478     on the configuration of the user's system.

   479 

   480     \section1 Path Manipulation and Strings

   481 

   482     Paths containing "." elements that reference the current directory at that

   483     point in the path, ".." elements that reference the parent directory, and

   484     symbolic links can be reduced to a canonical form using the canonicalPath()

   485     function.

   486 

   487     Paths can also be simplified by using cleanPath() to remove redundant "/"

   488     and ".." elements.

   489 

   490     It is sometimes necessary to be able to show a path in the native

   491     representation for the user's platform. The static toNativeSeparators()

   492     function returns a copy of the specified path in which each directory

   493     separator is replaced by the appropriate separator for the underlying

   494     operating system.

   495 

   496     \section1 Examples

   497 

   498     Check if a directory exists:

   499 

   500     \snippet doc/src/snippets/code/src_corelib_io_qdir.cpp 4

   501 

   502     (We could also use the static convenience function

   503     QFile::exists().)

   504 

   505     Traversing directories and reading a file:

   506 

   507     \snippet doc/src/snippets/code/src_corelib_io_qdir.cpp 5

   508 

   509     A program that lists all the files in the current directory

   510     (excluding symbolic links), sorted by size, smallest first:

   511 

   512     \snippet doc/src/snippets/qdir-listfiles/main.cpp 0

   513 

   514     \sa QFileInfo, QFile, QFileDialog, QApplication::applicationDirPath(), {Find Files Example}

   515 */

   516 

   517 /*!

   518     Constructs a QDir pointing to the given directory \a path. If path

   519     is empty the program's working directory, ("."), is used.

   520 

   521     \sa currentPath()

   522 */

   523 

   524 QDir::QDir(const QString &path) : d_ptr(new QDirPrivate(this))

   525 {

   526     Q_D(QDir);

   527     d->setPath(path.isEmpty() ? QString::fromLatin1(".") : path);

   528     d->data->nameFilters = QStringList(QString::fromLatin1("*"));

   529     d->data->filters = AllEntries;

   530     d->data->sort = SortFlags(Name | IgnoreCase);

   531 }

   532 

   533 /*!

   534     Constructs a QDir with path \a path, that filters its entries by

   535     name using \a nameFilter and by attributes using \a filters. It

   536     also sorts the names using \a sort.

   537 

   538     The default \a nameFilter is an empty string, which excludes

   539     nothing; the default \a filters is \l AllEntries, which also means

   540     exclude nothing. The default \a sort is \l Name | \l IgnoreCase,

   541     i.e. sort by name case-insensitively.

   542 

   543     If \a path is an empty string, QDir uses "." (the current

   544     directory). If \a nameFilter is an empty string, QDir uses the

   545     name filter "*" (all files).

   546 

   547     Note that \a path need not exist.

   548 

   549     \sa exists(), setPath(), setNameFilter(), setFilter(), setSorting()

   550 */

   551 

   552 QDir::QDir(const QString &path, const QString &nameFilter,

   553            SortFlags sort, Filters filters)  : d_ptr(new QDirPrivate(this))

   554 {

   555     Q_D(QDir);

   556     d->setPath(path.isEmpty() ? QString::fromLatin1(".") : path);

   557     d->data->nameFilters = QDir::nameFiltersFromString(nameFilter);

   558     bool empty = d->data->nameFilters.isEmpty();

   559     if(!empty) {

   560         empty = true;

   561         for(int i = 0; i < d->data->nameFilters.size(); ++i) {

   562             if(!d->data->nameFilters.at(i).isEmpty()) {

   563                 empty = false;

   564                 break;

   565             }

   566         }

   567     }

   568     if (empty)

   569         d->data->nameFilters = QStringList(QString::fromLatin1("*"));

   570     d->data->sort = sort;

   571     d->data->filters = filters;

   572 }

   573 

   574 /*!

   575     Constructs a QDir object that is a copy of the QDir object for

   576     directory \a dir.

   577 

   578     \sa operator=()

   579 */

   580 

   581 QDir::QDir(const QDir &dir)  : d_ptr(new QDirPrivate(this, &dir))

   582 {

   583 }

   584 

   585 /*!

   586     Destroys the QDir object frees up its resources. This has no

   587     effect on the underlying directory in the file system.

   588 */

   589 

   590 QDir::~QDir()

   591 {

   592 }

   593 

   594 /*!

   595     Sets the path of the directory to \a path. The path is cleaned of

   596     redundant ".", ".." and of multiple separators. No check is made

   597     to see whether a directory with this path actually exists; but you

   598     can check for yourself using exists().

   599 

   600     The path can be either absolute or relative. Absolute paths begin

   601     with the directory separator "/" (optionally preceded by a drive

   602     specification under Windows). Relative file names begin with a

   603     directory name or a file name and specify a path relative to the

   604     current directory. An example of an absolute path is the string

   605     "/tmp/quartz", a relative path might look like "src/fatlib".

   606 

   607     \sa path(), absolutePath(), exists(), cleanPath(), dirName(),

   608       absoluteFilePath(), isRelative(), makeAbsolute()

   609 */

   610 

   611 void QDir::setPath(const QString &path)

   612 {

   613     Q_D(QDir);

   614     d->setPath(path);

   615 }

   616 

   617 /*!

   618     Returns the path. This may contain symbolic links, but never

   619     contains redundant ".", ".." or multiple separators.

   620 

   621     The returned path can be either absolute or relative (see

   622     setPath()).

   623 

   624     \sa setPath(), absolutePath(), exists(), cleanPath(), dirName(),

   625     absoluteFilePath(), toNativeSeparators(), makeAbsolute()

   626 */

   627 

   628 QString QDir::path() const

   629 {

   630     Q_D(const QDir);

   631     return d->data->path;

   632 }

   633 

   634 /*!

   635     Returns the absolute path (a path that starts with "/" or with a

   636     drive specification), which may contain symbolic links, but never

   637     contains redundant ".", ".." or multiple separators.

   638 

   639     \sa setPath(), canonicalPath(), exists(), cleanPath(),

   640     dirName(), absoluteFilePath()

   641 */

   642 

   643 QString QDir::absolutePath() const

   644 {

   645     Q_D(const QDir);

   646     QString ret = d->data->path;

   647     if (QDir::isRelativePath(ret))

   648         ret = absoluteFilePath(QString::fromLatin1(""));

   649     return cleanPath(ret);

   650 }

   651 

   652 

   653 /*!

   654     Returns the canonical path, i.e. a path without symbolic links or

   655     redundant "." or ".." elements.

   656 

   657     On systems that do not have symbolic links this function will

   658     always return the same string that absolutePath() returns. If the

   659     canonical path does not exist (normally due to dangling symbolic

   660     links) canonicalPath() returns an empty string.

   661 

   662     Example:

   663 

   664     \snippet doc/src/snippets/code/src_corelib_io_qdir.cpp 6

   665 

   666     \sa path(), absolutePath(), exists(), cleanPath(), dirName(),

   667         absoluteFilePath()

   668 */

   669 

   670 QString QDir::canonicalPath() const

   671 {

   672     Q_D(const QDir);

   673 

   674     if(!d->data->fileEngine)

   675         return QLatin1String("");

   676     return cleanPath(d->data->fileEngine->fileName(QAbstractFileEngine::CanonicalName));

   677 }

   678 

   679 /*!

   680     Returns the name of the directory; this is \e not the same as the

   681     path, e.g. a directory with the name "mail", might have the path

   682     "/var/spool/mail". If the directory has no name (e.g. it is the

   683     root directory) an empty string is returned.

   684 

   685     No check is made to ensure that a directory with this name

   686     actually exists; but see exists().

   687 

   688     \sa path(), filePath(), absolutePath(), absoluteFilePath()

   689 */

   690 

   691 QString QDir::dirName() const

   692 {

   693     Q_D(const QDir);

   694     int pos = d->data->path.lastIndexOf(QLatin1Char('/'));

   695     if (pos == -1)

   696         return d->data->path;

   697     return d->data->path.mid(pos + 1);

   698 }

   699 

   700 /*!

   701     Returns the path name of a file in the directory. Does \e not

   702     check if the file actually exists in the directory; but see

   703     exists(). If the QDir is relative the returned path name will also

   704     be relative. Redundant multiple separators or "." and ".."

   705     directories in \a fileName are not removed (see cleanPath()).

   706 

   707     \sa dirName() absoluteFilePath(), isRelative(), canonicalPath()

   708 */

   709 

   710 QString QDir::filePath(const QString &fileName) const

   711 {

   712     Q_D(const QDir);

   713     if (isAbsolutePath(fileName))

   714         return QString(fileName);

   715 

   716     QString ret = d->data->path;

   717     if(!fileName.isEmpty()) {

   718         if (!ret.isEmpty() && ret[(int)ret.length()-1] != QLatin1Char('/') && fileName[0] != QLatin1Char('/'))

   719             ret += QLatin1Char('/');

   720         ret += fileName;

   721     }

   722     return ret;

   723 }

   724 

   725 /*!

   726     Returns the absolute path name of a file in the directory. Does \e

   727     not check if the file actually exists in the directory; but see

   728     exists(). Redundant multiple separators or "." and ".."

   729     directories in \a fileName are not removed (see cleanPath()).

   730 

   731     \sa relativeFilePath() filePath() canonicalPath()

   732 */

   733 

   734 QString QDir::absoluteFilePath(const QString &fileName) const

   735 {

   736     Q_D(const QDir);

   737     if (isAbsolutePath(fileName))

   738         return fileName;

   739     if(!d->data->fileEngine)

   740         return fileName;

   741 

   742     QString ret;

   743 #ifndef QT_NO_FSFILEENGINE

   744     if (isRelativePath(d->data->path)) //get pwd

   745         ret = QFSFileEngine::currentPath(fileName);

   746 #endif

   747     if(!d->data->path.isEmpty() && d->data->path != QLatin1String(".")) {

   748         if (!ret.isEmpty() && !ret.endsWith(QLatin1Char('/')))

   749             ret += QLatin1Char('/');

   750         ret += d->data->path;

   751     }

   752     if (!fileName.isEmpty()) {

   753         if (!ret.isEmpty() && !ret.endsWith(QLatin1Char('/')))

   754             ret += QLatin1Char('/');

   755         ret += fileName;

   756     }

   757     return ret;

   758 }

   759 

   760 /*!

   761     Returns the path to \a fileName relative to the directory.

   762 

   763     \snippet doc/src/snippets/code/src_corelib_io_qdir.cpp 7

   764 

   765     \sa absoluteFilePath() filePath() canonicalPath()

   766 */

   767 

   768 QString QDir::relativeFilePath(const QString &fileName) const

   769 {

   770     QString dir = absolutePath();

   771     QString file = cleanPath(fileName);

   772 

   773     if (isRelativePath(file) || isRelativePath(dir))

   774         return file;

   775 

   776     QString dirDrive = driveSpec(dir);

   777     QString fileDrive = driveSpec(file);

   778 

   779     bool fileDriveMissing = false;

   780     if (fileDrive.isEmpty()) {

   781         fileDrive = dirDrive;

   782         fileDriveMissing = true;

   783     }

   784 

   785 #ifdef Q_OS_WIN

   786     if (fileDrive.toLower() != dirDrive.toLower()

   787         || (file.startsWith(QLatin1String("//"))

   788         && !dir.startsWith(QLatin1String("//"))))

   789 #elif defined(Q_OS_SYMBIAN)

   790     if (fileDrive.toLower() != dirDrive.toLower())

   791 #else

   792     if (fileDrive != dirDrive)

   793 #endif

   794         return file;

   795 

   796     dir.remove(0, dirDrive.size());

   797     if (!fileDriveMissing)

   798         file.remove(0, fileDrive.size());

   799 

   800     QString result;

   801     QStringList dirElts = dir.split(QLatin1Char('/'), QString::SkipEmptyParts);

   802     QStringList fileElts = file.split(QLatin1Char('/'), QString::SkipEmptyParts);

   803 

   804     int i = 0;

   805     while (i < dirElts.size() && i < fileElts.size() &&

   806 #if defined(Q_OS_WIN) || defined(Q_OS_SYMBIAN)

   807            dirElts.at(i).toLower() == fileElts.at(i).toLower())

   808 #else

   809            dirElts.at(i) == fileElts.at(i))

   810 #endif

   811         ++i;

   812 

   813     for (int j = 0; j < dirElts.size() - i; ++j)

   814         result += QLatin1String("../");

   815 

   816     for (int j = i; j < fileElts.size(); ++j) {

   817         result += fileElts.at(j);

   818         if (j < fileElts.size() - 1)

   819             result += QLatin1Char('/');

   820     }

   821 

   822     return result;

   823 }

   824 

   825 /*!

   826     \obsolete

   827 

   828     Use QDir::toNativeSeparators() instead.

   829 */

   830 QString QDir::convertSeparators(const QString &pathName)

   831 {

   832     return toNativeSeparators(pathName);

   833 }

   834 

   835 /*!

   836     \since 4.2

   837 

   838     Returns \a pathName with the '/' separators converted to

   839     separators that are appropriate for the underlying operating

   840     system.

   841 

   842     On Windows, toNativeSeparators("c:/winnt/system32") returns

   843     "c:\\winnt\\system32".

   844 

   845     The returned string may be the same as the argument on some

   846     operating systems, for example on Unix.

   847 

   848     \sa fromNativeSeparators(), separator()

   849 */

   850 QString QDir::toNativeSeparators(const QString &pathName)

   851 {

   852     QString n(pathName);

   853 #if defined(Q_FS_FAT) || defined(Q_OS_OS2EMX) || defined(Q_OS_SYMBIAN)

   854     for (int i=0; i<(int)n.length(); i++) {

   855         if (n[i] == QLatin1Char('/'))

   856             n[i] = QLatin1Char('\\');

   857     }

   858 #endif

   859     return n;

   860 }

   861 

   862 /*!

   863     \since 4.2

   864 

   865     Returns \a pathName using '/' as file separator. On Windows,

   866     for instance, fromNativeSeparators("\c{c:\\winnt\\system32}") returns

   867     "c:/winnt/system32".

   868 

   869     The returned string may be the same as the argument on some

   870     operating systems, for example on Unix.

   871 

   872     \sa toNativeSeparators(), separator()

   873 */

   874 QString QDir::fromNativeSeparators(const QString &pathName)

   875 {

   876     QString n(pathName);

   877 #if defined(Q_FS_FAT) || defined(Q_OS_OS2EMX) || defined(Q_OS_SYMBIAN)

   878     for (int i=0; i<(int)n.length(); i++) {

   879         if (n[i] == QLatin1Char('\\'))

   880             n[i] = QLatin1Char('/');

   881     }

   882 #endif

   883     return n;

   884 }

   885 

   886 /*!

   887     Changes the QDir's directory to \a dirName.

   888 

   889     Returns true if the new directory exists and is readable;

   890     otherwise returns false. Note that the logical cd() operation is

   891     not performed if the new directory does not exist.

   892 

   893     Calling cd("..") is equivalent to calling cdUp().

   894 

   895     \sa cdUp(), isReadable(), exists(), path()

   896 */

   897 

   898 bool QDir::cd(const QString &dirName)

   899 {

   900     Q_D(QDir);

   901 

   902     if (dirName.isEmpty() || dirName == QLatin1String("."))

   903         return true;

   904     QString newPath = d->data->path;

   905     if (isAbsolutePath(dirName)) {

   906         newPath = cleanPath(dirName);

   907     } else {

   908         if (isRoot()) {

   909             if (dirName == QLatin1String(".."))

   910                 return false;

   911         } else {

   912             newPath += QLatin1Char('/');

   913         }

   914 

   915         newPath += dirName;

   916         if (dirName.indexOf(QLatin1Char('/')) >= 0

   917             || d->data->path == QLatin1String(".")

   918             || dirName == QLatin1String("..")) {

   919             newPath = cleanPath(newPath);

   920             /*

   921               If newPath starts with .., we convert it to absolute to

   922               avoid infinite looping on

   923 

   924                   QDir dir(".");

   925                   while (dir.cdUp())

   926                       ;

   927             */

   928             if (newPath.startsWith(QLatin1String(".."))) {

   929                 newPath = QFileInfo(newPath).absoluteFilePath();

   930             }

   931         }

   932     }

   933     {

   934         QFileInfo fi(newPath);

   935         if (!(fi.exists() && fi.isDir()))

   936             return false;

   937     }

   938 

   939     d->setPath(newPath);

   940     refresh();

   941     return true;

   942 }

   943 

   944 /*!

   945     Changes directory by moving one directory up from the QDir's

   946     current directory.

   947 

   948     Returns true if the new directory exists and is readable;

   949     otherwise returns false. Note that the logical cdUp() operation is

   950     not performed if the new directory does not exist.

   951 

   952     \sa cd(), isReadable(), exists(), path()

   953 */

   954 

   955 bool QDir::cdUp()

   956 {

   957     return cd(QString::fromLatin1(".."));

   958 }

   959 

   960 /*!

   961     Returns the string list set by setNameFilters()

   962 */

   963 

   964 QStringList QDir::nameFilters() const

   965 {

   966     Q_D(const QDir);

   967 

   968     return d->data->nameFilters;

   969 }

   970 

   971 /*!

   972     Sets the name filters used by entryList() and entryInfoList() to the

   973     list of filters specified by \a nameFilters.

   974 

   975     Each name filter is a wildcard (globbing) filter that understands

   976     \c{*} and \c{?} wildcards. (See \l{QRegExp wildcard matching}.)

   977 

   978     For example, the following code sets three name filters on a QDir

   979     to ensure that only files with extensions typically used for C++

   980     source files are listed:

   981 

   982     \snippet doc/src/snippets/qdir-namefilters/main.cpp 0

   983 

   984     \sa nameFilters(), setFilter()

   985 */

   986 

   987 void QDir::setNameFilters(const QStringList &nameFilters)

   988 {

   989     Q_D(QDir);

   990     d->detach();

   991     d->data->nameFilters = nameFilters;

   992 }

   993 

   994 /*!

   995     \obsolete

   996     Adds \a path to the search paths searched in to find resources

   997     that are not specified with an absolute path. The default search

   998     path is to search only in the root (\c{:/}).

   999 

  1000     Use QDir::addSearchPath() with a prefix instead.

  1001 

  1002     \sa {The Qt Resource System}, QResource::addSearchPath()

  1003 */

  1004 

  1005 void QDir::addResourceSearchPath(const QString &path)

  1006 {

  1007 #ifdef QT_BUILD_CORE_LIB

  1008     QResource::addSearchPath(path);

  1009 #else

  1010     Q_UNUSED(path)

  1011 #endif

  1012 }

  1013 

  1014 #ifdef QT_BUILD_CORE_LIB

  1015 /*!

  1016     \since 4.3

  1017 

  1018     Sets or replaces Qt's search paths for file names with the prefix \a prefix

  1019     to \a searchPaths.

  1020 

  1021     To specify a prefix for a file name, prepend the prefix followed by a single

  1022     colon (e.g., "images:undo.png", "xmldocs:books.xml"). \a prefix can only

  1023     contain letters or numbers (e.g., it cannot contain a colon, nor a slash).

  1024 

  1025     Qt uses this search path to locate files with a known prefix. The search

  1026     path entries are tested in order, starting with the first entry.

  1027 

  1028     \snippet doc/src/snippets/code/src_corelib_io_qdir.cpp 8

  1029 

  1030     File name prefix must be at least 2 characters long to avoid conflicts with

  1031     Windows drive letters.

  1032 

  1033     Search paths may contain paths to \l{The Qt Resource System}.

  1034 */

  1035 void QDir::setSearchPaths(const QString &prefix, const QStringList &searchPaths)

  1036 {

  1037     if (prefix.length() < 2) {

  1038         qWarning("QDir::setSearchPaths: Prefix must be longer than 1 character");

  1039         return;

  1040     }

  1041 

  1042     for (int i = 0; i < prefix.count(); i++) {

  1043         if (!prefix.at(i).isLetterOrNumber()) {

  1044             qWarning("QDir::setSearchPaths: Prefix can only contain letters or numbers");

  1045             return;

  1046         }

  1047     }

  1048 

  1049     QWriteLocker lock(&QCoreGlobalData::instance()->dirSearchPathsLock);

  1050     QMap<QString, QStringList> &paths = QCoreGlobalData::instance()->dirSearchPaths;

  1051     if (searchPaths.isEmpty()) {

  1052         paths.remove(prefix);

  1053     } else {

  1054         paths.insert(prefix, searchPaths);

  1055     }

  1056 }

  1057 

  1058 /*!

  1059     \since 4.3

  1060 

  1061     Adds \a path to the search path for \a prefix.

  1062 

  1063     \sa setSearchPaths()

  1064 */

  1065 void QDir::addSearchPath(const QString &prefix, const QString &path)

  1066 {

  1067     if (path.isEmpty())

  1068         return;

  1069 

  1070     QWriteLocker lock(&QCoreGlobalData::instance()->dirSearchPathsLock);

  1071     QCoreGlobalData::instance()->dirSearchPaths[prefix] += path;

  1072 }

  1073 

  1074 /*!

  1075     \since 4.3

  1076 

  1077     Returns the search paths for \a prefix.

  1078 

  1079     \sa setSearchPaths(), addSearchPath()

  1080 */

  1081 QStringList QDir::searchPaths(const QString &prefix)

  1082 {

  1083     QReadLocker lock(&QCoreGlobalData::instance()->dirSearchPathsLock);

  1084     return QCoreGlobalData::instance()->dirSearchPaths.value(prefix);

  1085 }

  1086 

  1087 #endif // QT_BUILD_CORE_LIB

  1088 

  1089 /*!

  1090     Returns the value set by setFilter()

  1091 */

  1092 

  1093 QDir::Filters QDir::filter() const

  1094 {

  1095     Q_D(const QDir);

  1096 

  1097     return d->data->filters;

  1098 }

  1099 

  1100 /*!

  1101     \enum QDir::Filter

  1102 

  1103     This enum describes the filtering options available to QDir; e.g.

  1104     for entryList() and entryInfoList(). The filter value is specified

  1105     by combining values from the following list using the bitwise OR

  1106     operator:

  1107 

  1108     \value Dirs    List directories that match the filters.

  1109     \value AllDirs  List all directories; i.e. don't apply the filters

  1110                     to directory names.

  1111     \value Files   List files.

  1112     \value Drives  List disk drives (ignored under Unix).

  1113     \value NoSymLinks  Do not list symbolic links (ignored by operating

  1114                        systems that don't support symbolic links).

  1115     \value NoDotAndDotDot Do not list the special entries "." and "..".

  1116     \value AllEntries  List directories, files, drives and symlinks (this does not list

  1117                 broken symlinks unless you specify System).

  1118     \value Readable    List files for which the application has read

  1119                        access. The Readable value needs to be combined

  1120                        with Dirs or Files.

  1121     \value Writable    List files for which the application has write

  1122                        access. The Writable value needs to be combined

  1123                        with Dirs or Files.

  1124     \value Executable  List files for which the application has

  1125                        execute access. The Executable value needs to be

  1126                        combined with Dirs or Files.

  1127     \value Modified  Only list files that have been modified (ignored

  1128                      under Unix).

  1129     \value Hidden  List hidden files (on Unix, files starting with a .).

  1130     \value System  List system files (on Unix, FIFOs, sockets and

  1131                    device files)

  1132     \value CaseSensitive  The filter should be case sensitive.

  1133 

  1134     \omitvalue DefaultFilter