/****************************************************************************

**

** Copyright (C) 2010 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$

** No Commercial Usage

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

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

** contained in the Technology Preview License Agreement accompanying

** this package.

**

** GNU Lesser General Public License Usage

** Alternatively, 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.

**

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

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

**

**

**

**

**

**

**

**

** $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

{

    friend struct QScopedPointerDeleter<QDirPrivate>;

public:

    QDirPrivate(const QDir *copy = 0);

    ~QDirPrivate();

    void updateFileLists() const;

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

#ifdef QT3_SUPPORT

    QChar filterSepChar;

    bool matchAllDirs;

#endif

    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;

    }

    struct Data {

        inline Data()

            : ref(1), fileEngine(0), listsDirty(1)

        {}

        inline Data(const Data &copy)

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

              filters(copy.filters), fileEngine(0), listsDirty(1)

        {}

        inline ~Data()

        { delete fileEngine; }

        inline void clear() {

            listsDirty = 1;

            files.clear();

            fileInfos.clear();

        }

        mutable QAtomicInt ref;

        QString path;

        QStringList nameFilters;

        QDir::SortFlags sort;

        QDir::Filters filters;

        mutable QAbstractFileEngine *fileEngine;

        mutable uint listsDirty : 1;

        mutable QStringList files;

        mutable QFileInfoList fileInfos;

    } *data;

    inline void setPath(const QString &p)

    {

        detach(false);

        QString path = p;

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

                && path.length() > 1) {

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

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

#endif

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

        }

        delete data->fileEngine;

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

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

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

        data->clear();

    }

    inline void reset() {

        detach();

        data->clear();

    }

    void detach(bool createFileEngine = true);

};

QDirPrivate::QDirPrivate(const QDir *copy)

#ifdef QT3_SUPPORT

    : filterSepChar(0), matchAllDirs(false)

#endif

{

    if (copy) {

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

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

    } else {

        data = new QDirPrivate::Data;

    }

}

QDirPrivate::~QDirPrivate()

{

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

        delete data;

    data = 0;

}

/* 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) const

{

    // 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::updateFileLists() const

{

    if (data->listsDirty) {

        QFileInfoList l;

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

        while (it.hasNext()) {

            it.next();

            l.append(it.fileInfo());

        }

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

        data->listsDirty = 0;

    }

}

void QDirPrivate::detach(bool createFileEngine)

{

    qAtomicDetach(data);

    if (createFileEngine) {

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

        delete data->fileEngine;

        data->fileEngine = newFileEngine;

    }

}

/*!

    \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)

{

    Q_D(QDir);

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

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

    d->data->filters = AllEntries;

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

}

/*!

    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