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

**

** 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 "qdebug.h"

#include "qfile.h"

#include "qfsfileengine.h"

#include "qtemporaryfile.h"

#include "qlist.h"

#include "qfileinfo.h"

#include "private/qiodevice_p.h"

#include "private/qfile_p.h"

#if defined(QT_BUILD_CORE_LIB)

# include "qcoreapplication.h"

#endif

#ifdef QT_NO_QOBJECT

#define tr(X) QString::fromLatin1(X)

#endif

QT_BEGIN_NAMESPACE

static const int QFILE_WRITEBUFFER_SIZE = 16384;

static QByteArray locale_encode(const QString &f)

{

    // Mac always expects UTF-8... and decomposed...

    return f.normalized(QString::NormalizationForm_D).toUtf8();

#endif

}

static QString locale_decode(const QByteArray &f)

{

    // Mac always gives us UTF-8 and decomposed, we want that composed...

    return QString::fromUtf8(f).normalized(QString::NormalizationForm_C);

#endif

}

//************* QFilePrivate

QFile::EncoderFn QFilePrivate::encoder = locale_encode;

QFile::DecoderFn QFilePrivate::decoder = locale_decode;

QFilePrivate::QFilePrivate()

    : fileEngine(0), lastWasWrite(false),

{

}

QFilePrivate::~QFilePrivate()

{

    delete fileEngine;

    fileEngine = 0;

}

bool

QFilePrivate::openExternalFile(int flags, int fd)

{

#ifdef QT_NO_FSFILEENGINE

    Q_UNUSED(flags);

    Q_UNUSED(fd);

    return false;

#else

    delete fileEngine;

    fileEngine = 0;

    QFSFileEngine *fe = new QFSFileEngine;

    fe->setFileName(fileName);

    fileEngine = fe;

    return fe->open(QIODevice::OpenMode(flags), fd);

#endif

}

bool

QFilePrivate::openExternalFile(int flags, FILE *fh)

{

#ifdef QT_NO_FSFILEENGINE

    Q_UNUSED(flags);

    Q_UNUSED(fh);

    return false;

#else

    delete fileEngine;

    fileEngine = 0;

    QFSFileEngine *fe = new QFSFileEngine;

    fe->setFileName(fileName);

    fileEngine = fe;

    return fe->open(QIODevice::OpenMode(flags), fh);

#endif

}

inline bool QFilePrivate::ensureFlushed() const

{

    // This function ensures that the write buffer has been flushed (const

    // because certain const functions need to call it.

    if (lastWasWrite) {

        const_cast<QFilePrivate *>(this)->lastWasWrite = false;

        if (!const_cast<QFile *>(q_func())->flush())

            return false;

    }

    return true;

}

void

QFilePrivate::setError(QFile::FileError err)

{

    error = err;

    errorString.clear();

}

void

QFilePrivate::setError(QFile::FileError err, const QString &errStr)

{

    error = err;

    errorString = errStr;

}

void

QFilePrivate::setError(QFile::FileError err, int errNum)

{

    error = err;

    errorString = qt_error_string(errNum);

}

//************* QFile

/*!

    \class QFile

    \brief The QFile class provides an interface for reading from and writing to files.

    \ingroup io

    \reentrant

    QFile is an I/O device for reading and writing text and binary

    files and \l{The Qt Resource System}{resources}. A QFile may be

    used by itself or, more conveniently, with a QTextStream or

    QDataStream.

    The file name is usually passed in the constructor, but it can be

    set at any time using setFileName(). QFile expects the file

    separator to be '/' regardless of operating system. The use of

    other separators (e.g., '\\') is not supported.

    You can check for a file's existence using exists(), and remove a

    file using remove(). (More advanced file system related operations

    are provided by QFileInfo and QDir.)

    The file is opened with open(), closed with close(), and flushed

    with flush(). Data is usually read and written using QDataStream

    or QTextStream, but you can also call the QIODevice-inherited

    functions read(), readLine(), readAll(), write(). QFile also

    inherits getChar(), putChar(), and ungetChar(), which work one

    character at a time.

    The size of the file is returned by size(). You can get the

    current file position using pos(), or move to a new file position

    using seek(). If you've reached the end of the file, atEnd()

    returns true.

    \section1 Reading Files Directly

    The following example reads a text file line by line:

    \snippet doc/src/snippets/file/file.cpp 0

    The QIODevice::Text flag passed to open() tells Qt to convert

    Windows-style line terminators ("\\r\\n") into C++-style

    terminators ("\\n"). By default, QFile assumes binary, i.e. it

    doesn't perform any conversion on the bytes stored in the file.

    \section1 Using Streams to Read Files

    The next example uses QTextStream to read a text file

    line by line:

    \snippet doc/src/snippets/file/file.cpp 1

    QTextStream takes care of converting the 8-bit data stored on

    disk into a 16-bit Unicode QString. By default, it assumes that

    the user system's local 8-bit encoding is used (e.g., ISO 8859-1

    for most of Europe; see QTextCodec::codecForLocale() for

    details). This can be changed using setCodec().

    To write text, we can use operator<<(), which is overloaded to

    take a QTextStream on the left and various data types (including

    QString) on the right:

    \snippet doc/src/snippets/file/file.cpp 2

    QDataStream is similar, in that you can use operator<<() to write

    data and operator>>() to read it back. See the class

    documentation for details.

    When you use QFile, QFileInfo, and QDir to access the file system

    with Qt, you can use Unicode file names. On Unix, these file

    names are converted to an 8-bit encoding. If you want to use

    standard C++ APIs (\c <cstdio> or \c <iostream>) or

    platform-specific APIs to access files instead of QFile, you can

    use the encodeName() and decodeName() functions to convert

    between Unicode file names and 8-bit file names.

    On Unix, there are some special system files (e.g. in \c /proc) for which

    size() will always return 0, yet you may still be able to read more data

    from such a file; the data is generated in direct response to you calling

    read(). In this case, however, you cannot use atEnd() to determine if

    there is more data to read (since atEnd() will return true for a file that

    claims to have size 0). Instead, you should either call readAll(), or call

    read() or readLine() repeatedly until no more data can be read. The next

    example uses QTextStream to read \c /proc/modules line by line:

    \snippet doc/src/snippets/file/file.cpp 3

    \section1 Signals

    Unlike other QIODevice implementations, such as QTcpSocket, QFile does not

    emit the aboutToClose(), bytesWritten(), or readyRead() signals. This

    implementation detail means that QFile is not suitable for reading and

    writing certain types of files, such as device files on Unix platforms.

    \section1 Platform Specific Issues

    File permissions are handled differently on Linux/Mac OS X and

    Windows.  In a non \l{QIODevice::isWritable()}{writable}

    directory on Linux, files cannot be created. This is not always

    the case on Windows, where, for instance, the 'My Documents'

    directory usually is not writable, but it is still possible to

    create files in it.

    \sa QTextStream, QDataStream, QFileInfo, QDir, {The Qt Resource System}

*/

/*!

    \enum QFile::FileError

    This enum describes the errors that may be returned by the error()

    function.

    \value NoError          No error occurred.

    \value ReadError        An error occurred when reading from the file.

    \value WriteError       An error occurred when writing to the file.

    \value FatalError       A fatal error occurred.

    \value ResourceError

    \value OpenError        The file could not be opened.

    \value AbortError       The operation was aborted.

    \value TimeOutError     A timeout occurred.

    \value UnspecifiedError An unspecified error occurred.

    \value RemoveError      The file could not be removed.

    \value RenameError      The file could not be renamed.

    \value PositionError    The position in the file could not be changed.

    \value ResizeError      The file could not be resized.

    \value PermissionsError The file could not be accessed.

    \value CopyError        The file could not be copied.

    \omitvalue ConnectError

*/

/*!

    \enum QFile::Permission

    This enum is used by the permission() function to report the

    permissions and ownership of a file. The values may be OR-ed

    together to test multiple permissions and ownership values.

    \value ReadOwner The file is readable by the owner of the file.

    \value WriteOwner The file is writable by the owner of the file.

    \value ExeOwner The file is executable by the owner of the file.

    \value ReadUser The file is readable by the user.

    \value WriteUser The file is writable by the user.

    \value ExeUser The file is executable by the user.

    \value ReadGroup The file is readable by the group.

    \value WriteGroup The file is writable by the group.

    \value ExeGroup The file is executable by the group.

    \value ReadOther The file is readable by anyone.

    \value WriteOther The file is writable by anyone.

    \value ExeOther The file is executable by anyone.

    \warning Because of differences in the platforms supported by Qt,

    the semantics of ReadUser, WriteUser and ExeUser are

    platform-dependent: On Unix, the rights of the owner of the file

    are returned and on Windows the rights of the current user are

    returned. This behavior might change in a future Qt version.

    Note that Qt does not by default check for permissions on NTFS

    file systems, as this may decrease the performance of file

    handling considerably. It is possible to force permission checking

    on NTFS by including the following code in your source:

    \snippet doc/src/snippets/ntfsp.cpp 0

    Permission checking is then turned on and off by incrementing and

    decrementing \c qt_ntfs_permission_lookup by 1.

    \snippet doc/src/snippets/ntfsp.cpp 1

*/

#ifdef QT3_SUPPORT

/*!

    \typedef QFile::PermissionSpec

    Use QFile::Permission instead.

*/

#endif

#ifdef QT_NO_QOBJECT

QFile::QFile()

    : QIODevice(*new QFilePrivate)

{

}

QFile::QFile(const QString &name)

    : QIODevice(*new QFilePrivate)

{

    d_func()->fileName = name;

}

QFile::QFile(QFilePrivate &dd)

    : QIODevice(dd)

{

}

#else

/*!

    \internal

*/

QFile::QFile()

    : QIODevice(*new QFilePrivate, 0)

{

}

/*!

    Constructs a new file object with the given \a parent.

*/

QFile::QFile(QObject *parent)

    : QIODevice(*new QFilePrivate, parent)

{

}

/*!

    Constructs a new file object to represent the file with the given \a name.

*/

QFile::QFile(const QString &name)

    : QIODevice(*new QFilePrivate, 0)

{

    Q_D(QFile);

    d->fileName = name;

}

/*!

    Constructs a new file object with the given \a parent to represent the

    file with the specified \a name.

*/

QFile::QFile(const QString &name, QObject *parent)

    : QIODevice(*new QFilePrivate, parent)

{

    Q_D(QFile);

    d->fileName = name;

}

/*!

    \internal

*/

QFile::QFile(QFilePrivate &dd, QObject *parent)

    : QIODevice(dd, parent)

{

}

#endif

/*!

    Destroys the file object, closing it if necessary.

*/

QFile::~QFile()

{

    close();

}

/*!

    Returns the name set by setFileName() or to the QFile

    constructors.

    \sa setFileName(), QFileInfo::fileName()

*/

QString QFile::fileName() const

{

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

}

/*!

    Sets the \a name of the file. The name can have no path, a

    relative path, or an absolute path.

    Do not call this function if the file has already been opened.

    If the file name has no path or a relative path, the path used

    will be the application's current directory path

    \e{at the time of the open()} call.

    Example:

    \snippet doc/src/snippets/code/src_corelib_io_qfile.cpp 0

    Note that the directory separator "/" works for all operating

    systems supported by Qt.

    \sa fileName(), QFileInfo, QDir

*/

void

QFile::setFileName(const QString &name)

{

    Q_D(QFile);

    if (isOpen()) {

        qWarning("QFile::setFileName: File (%s) is already opened",

                 qPrintable(fileName()));

        close();

    }

    if(d->fileEngine) { //get a new file engine later

        delete d->fileEngine;

        d->fileEngine = 0;

    }

    d->fileName = name;

}

/*!

    \fn QString QFile::decodeName(const char *localFileName)

    \overload

    Returns the Unicode version of the given \a localFileName. See

    encodeName() for details.

*/

/*!

    By default, this function converts \a fileName to the local 8-bit

    encoding determined by the user's locale. This is sufficient for

    file names that the user chooses. File names hard-coded into the

    application should only use 7-bit ASCII filename characters.

    \sa decodeName() setEncodingFunction()

*/

QByteArray

QFile::encodeName(const QString &fileName)

{

    return (*QFilePrivate::encoder)(fileName);

}

/*!

    \typedef QFile::EncoderFn

    This is a typedef for a pointer to a function with the following

    signature:

    \snippet doc/src/snippets/code/src_corelib_io_qfile.cpp 1

    \sa setEncodingFunction(), encodeName()

*/

/*!

    This does the reverse of QFile::encodeName() using \a localFileName.

    \sa setDecodingFunction(), encodeName()

*/

QString

QFile::decodeName(const QByteArray &localFileName)

{

    return (*QFilePrivate::decoder)(localFileName);

}

/*!

    \fn void QFile::setEncodingFunction(EncoderFn function)

    \nonreentrant

    Sets the \a function for encoding Unicode file names. The

    default encodes in the locale-specific 8-bit encoding.

    \sa encodeName(), setDecodingFunction()

*/

void

QFile::setEncodingFunction(EncoderFn f)

{

    if (!f)

        f = locale_encode;

    QFilePrivate::encoder = f;

}

/*!