/*!
Opens the file using OpenMode \a mode, returning true if successful;
otherwise false.
The \a mode must be QIODevice::ReadOnly, QIODevice::WriteOnly, or
QIODevice::ReadWrite. It may also have additional flags, such as
QIODevice::Text and QIODevice::Unbuffered.
\note In \l{QIODevice::}{WriteOnly} or \l{QIODevice::}{ReadWrite}
mode, if the relevant file does not already exist, this function
will try to create a new file before opening it.
\sa QIODevice::OpenMode, setFileName()
*/
bool QFile::open(OpenMode mode)
{
Q_D(QFile);
if (isOpen()) {
qWarning("QFile::open: File (%s) already open", qPrintable(fileName()));
return false;
}
if (mode & Append)
mode |= WriteOnly;
unsetError();
if ((mode & (ReadOnly | WriteOnly)) == 0) {
qWarning("QIODevice::open: File access not specified");
return false;
}
// QIODevice provides the buffering, so there's no need to request it from the file engine.
if (fileEngine()->open(mode | QIODevice::Unbuffered))
{
QIODevice::open(mode);
if (mode & Append) {
//The file engine should have done this in open(),
//this is a workaround for backward compatibility
fileEngine()->seek(size());
}
return true;
}
QFile::FileError err = d->fileEngine->error();
if(err == QFile::UnspecifiedError)
err = QFile::OpenError;
d->setError(err, d->fileEngine->errorString());
return false;
}
/*!
Opens the file using OpenMode \a mode, returning true if successful;
otherwise false.
The \a mode must be QIODevice::ReadOnly, QIODevice::WriteOnly, or
QIODevice::ReadWrite. It may also have additional flags, such as
QIODevice::Text and QIODevice::Unbuffered.
\note In \l{QIODevice::}{WriteOnly} or \l{QIODevice::}{ReadWrite}
mode, if the relevant file does not already exist, this function
will try to create a new file before opening it.
\note Because of limitations in the native API, QFile ignores the
Unbuffered flag on Windows.
\sa QIODevice::OpenMode, setFileName()
*/
bool QFile::open(OpenMode mode)
{
Q_D(QFile);
if (isOpen()) {
qWarning("QFile::open: File (%s) already open", qPrintable(fileName()));
return false;
}
if (mode & Append)
mode |= WriteOnly;
unsetError();
if ((mode & (ReadOnly | WriteOnly)) == 0) {
qWarning("QIODevice::open: File access not specified");
return false;
}
if (fileEngine()->open(mode)) {
QIODevice::open(mode);
if (mode & Append)
seek(size());
return true;
}
QFile::FileError err = fileEngine()->error();
if(err == QFile::UnspecifiedError)
err = QFile::OpenError;
d->setError(err, fileEngine()->errorString());
return false;
}
void
QFile::close()
{
Q_D(QFile);
if(!isOpen())
return;
flush();
QIODevice::close();
unsetError();
if(!fileEngine()->close())
d->setError(fileEngine()->error(), fileEngine()->errorString());
}
/*!
\reimp
*/
qint64 QFile::readLineData(char *data, qint64 maxlen)
{
Q_D(QFile);
if (!d->ensureFlushed())
return -1;
if (fileEngine()->supportsExtension(QAbstractFileEngine::FastReadLineExtension))
return fileEngine()->readLine(data, maxlen);
// Fall back to QIODevice's readLine implementation if the engine
// cannot do it faster.
return QIODevice::readLineData(data, maxlen);
}
bool
QFile::resize(qint64 sz)
{
Q_D(QFile);
if (!d->ensureFlushed())
return false;
if (isOpen() && fileEngine()->pos() > sz)
seek(sz);
if(fileEngine()->setSize(sz)) {
unsetError();
return true;
}
d->setError(QFile::ResizeError, errno);
return false;
}
qint64 QFile::size() const
{
Q_D(const QFile);
if (!d->ensureFlushed())
return 0;
return fileEngine()->size();
}
bool
QFile::exists() const
{
// 0x1000000 = QAbstractFileEngine::Refresh, forcing an update
return (fileEngine()->fileFlags(QAbstractFileEngine::FlagsMask
| QAbstractFileEngine::FileFlag(0x1000000)) & QAbstractFileEngine::ExistsFlag);
}
QString QTemporaryFile::fileName() const
{
Q_D(const QTemporaryFile);
if(d->fileName.isEmpty())
return QString();
return fileEngine()->fileName(QAbstractFileEngine::DefaultName);
}
qint64 QFile::size() const
{
Q_D(const QFile);
if (!d->ensureFlushed())
return 0;
d->cachedSize = fileEngine()->size();
return d->cachedSize;
}
QAbstractFileEngine* QTemporaryFile_QtDShell::__override_fileEngine(bool static_call) const
{
if (static_call) {
return QTemporaryFile::fileEngine();
} else {
return fileEngine();
}
}
bool QFile::setPermissions(Permissions permissions)
{
Q_D(QFile);
if(fileEngine()->setPermissions(permissions)) {
unsetError();
return true;
}
d->setError(QFile::PermissionsError, d->fileEngine->errorString());
return false;
}
int
QFile::handle() const
{
if (!isOpen())
return -1;
if (QAbstractFileEngine *engine = fileEngine())
return engine->handle();
return -1;
}
qint64 QFile::readData(char *data, qint64 len)
{
Q_D(QFile);
d->error = NoError;
if (!d->ensureFlushed())
return -1;
qint64 ret = -1;
qint64 read = fileEngine()->read(data, len);
if (read != -1)
ret = read;
if(ret < 0) {
QFile::FileError err = fileEngine()->error();
if(err == QFile::UnspecifiedError)
err = QFile::ReadError;
d->setError(err, fileEngine()->errorString());
}
return ret;
}
bool QFile::seek(qint64 off)
{
Q_D(QFile);
if (!isOpen()) {
qWarning("QFile::seek: IODevice is not open");
return false;
}
if (!d->ensureFlushed())
return false;
if (!fileEngine()->seek(off) || !QIODevice::seek(off)) {
QFile::FileError err = fileEngine()->error();
if(err == QFile::UnspecifiedError)
err = QFile::PositionError;
d->setError(err, fileEngine()->errorString());
return false;
}
d->error = NoError;
return true;
}
bool
QFile::flush()
{
Q_D(QFile);
if (!d->writeBuffer.isEmpty()) {
qint64 size = d->writeBuffer.size();
if (_qfile_writeData(d->fileEngine ? d->fileEngine : fileEngine(),
&d->writeBuffer) != size) {
QFile::FileError err = fileEngine()->error();
if(err == QFile::UnspecifiedError)
err = QFile::WriteError;
d->setError(err, fileEngine()->errorString());
return false;
}
}
if (!fileEngine()->flush()) {
QFile::FileError err = fileEngine()->error();
if(err == QFile::UnspecifiedError)
err = QFile::WriteError;
d->setError(err, fileEngine()->errorString());
return false;
}
return true;
}
/*!
\since 4.4
Maps \a size bytes of the file into memory starting at \a offset. A file
should be open for a map to succeed but the file does not need to stay
open after the memory has been mapped. When the QFile is destroyed
or a new file is opened with this object, any maps that have not been
unmapped will automatically be unmapped.
Any mapping options can be passed through \a flags.
Returns a pointer to the memory or 0 if there is an error.
\note On Windows CE 5.0 the file will be closed before mapping occurs.
\sa unmap(), QAbstractFileEngine::supportsExtension()
*/
uchar *QFile::map(qint64 offset, qint64 size, MemoryMapFlags flags)
{
Q_D(QFile);
if (fileEngine()
&& d->fileEngine->supportsExtension(QAbstractFileEngine::MapExtension)) {
unsetError();
uchar *address = d->fileEngine->map(offset, size, flags);
if (address == 0)
d->setError(d->fileEngine->error(), d->fileEngine->errorString());
return address;
}
return 0;
}
/*!
\since 4.4
Unmaps the memory \a address.
Returns true if the unmap succeeds; false otherwise.
\sa map(), QAbstractFileEngine::supportsExtension()
*/
bool QFile::unmap(uchar *address)
{
Q_D(QFile);
if (fileEngine()
&& d->fileEngine->supportsExtension(QAbstractFileEngine::UnMapExtension)) {
unsetError();
bool success = d->fileEngine->unmap(address);
if (!success)
d->setError(d->fileEngine->error(), d->fileEngine->errorString());
return success;
}
return false;
}
/*!
\since 4.4
Unmaps the memory \a address.
Returns true if the unmap succeeds; false otherwise.
\sa map(), QAbstractFileEngine::supportsExtension()
*/
bool QFile::unmap(uchar *address)
{
Q_D(QFile);
if (fileEngine()
&& d->fileEngine->supportsExtension(QAbstractFileEngine::UnMapExtension)) {
unsetError();
const bool success = d->fileEngine->unmap(address);
if (!success)
d->setError(d->fileEngine->error(), d->fileEngine->errorString());
return success;
}
d->setError(PermissionsError, tr("No file engine available or engine does not support UnMapExtension"));
return false;
}
bool
QFile::rename(const QString &newName)
{
Q_D(QFile);
if (d->fileName.isEmpty()) {
qWarning("QFile::rename: Empty or null file name");
return false;
}
if (QFile(newName).exists()) {
// ### Race condition. If a file is moved in after this, it /will/ be
// overwritten. On Unix, the proper solution is to use hardlinks:
// return ::link(old, new) && ::remove(old);
d->setError(QFile::RenameError, QLatin1String("Destination file exists"));
return false;
}
close();
if(error() == QFile::NoError) {
if (fileEngine()->rename(newName)) {
unsetError();
return true;
}
QFile in(fileName());
QFile out(newName);
if (in.open(QIODevice::ReadOnly)) {
if (out.open(QIODevice::WriteOnly | QIODevice::Truncate)) {
bool error = false;
char block[4096];
while (!in.atEnd()) {
qint64 read = in.read(block, sizeof(block));
if (read == -1) {
d->setError(QFile::RenameError, in.errorString());
error = true;
break;
}
if (read != out.write(block, read)) {
d->setError(QFile::RenameError, out.errorString());
error = true;
break;
}
}
if(!error)
in.remove();
return !error;
}
}
d->setError(QFile::RenameError, out.isOpen() ? in.errorString() : out.errorString());
}
return false;
}
qint64
QFile::writeData(const char *data, qint64 len)
{
Q_D(QFile);
d->error = NoError;
d->lastWasWrite = true;
bool buffered = !(d->openMode & Unbuffered);
// Flush buffered data if this read will overflow.
if (buffered && (d->writeBuffer.size() + len) > QFILE_WRITEBUFFER_SIZE) {
if (!flush())
return -1;
}
// Write directly to the engine if the block size is larger than
// the write buffer size.
if (!buffered || len > QFILE_WRITEBUFFER_SIZE) {
QAbstractFileEngine *fe = d->fileEngine ? d->fileEngine : fileEngine();
qint64 ret = fe->write(data, len);
if(ret < 0) {
QFile::FileError err = fileEngine()->error();
if(err == QFile::UnspecifiedError)
err = QFile::WriteError;
d->setError(err, fileEngine()->errorString());
}
return ret;
}
// Write to the buffer.
char *writePointer = d->writeBuffer.reserve(len);
if (len == 1)
*writePointer = *data;
else
::memcpy(writePointer, data, len);
return len;
}
bool QFile::atEnd() const
{
Q_D(const QFile);
if (!isOpen())
return true;
if (!d->ensureFlushed())
return false;
// If there's buffered data left, we're not at the end.
if (!d->buffer.isEmpty())
return false;
// If the file engine knows best, say what it says.
if (fileEngine()->supportsExtension(QAbstractFileEngine::AtEndExtension)) {
// Check if the file engine supports AtEndExtension, and if it does,
// check if the file engine claims to be at the end.
return fileEngine()->atEnd();
}
// Fall back to checking how much is available (will stat files).
return bytesAvailable() == 0;
}
bool
QFile::link(const QString &linkName)
{
Q_D(QFile);
if (d->fileName.isEmpty()) {
qWarning("QFile::link: Empty or null file name");
return false;
}
QFileInfo fi(linkName);
if(fileEngine()->link(fi.absoluteFilePath())) {
unsetError();
return true;
}
d->setError(QFile::RenameError, errno);
return false;
}
/*!
\reimp
Creates a unique file name for the temporary file, and opens it. You can
get the unique name later by calling fileName(). The file is guaranteed to
have been created by this function (i.e., it has never existed before).
*/
bool QTemporaryFile::open(OpenMode flags)
{
Q_D(QTemporaryFile);
if (!d->fileName.isEmpty()) {
if (static_cast<QTemporaryFileEngine*>(fileEngine())->isReallyOpen()) {
setOpenMode(flags);
return true;
}
}
if (QFile::open(flags)) {
d->fileName = d->fileEngine->fileName(QAbstractFileEngine::DefaultName);
return true;
}
return false;
}
bool QFile::resize(qint64 sz)
{
Q_D(QFile);
if (!d->ensureFlushed())
return false;
fileEngine();
if (isOpen() && d->fileEngine->pos() > sz)
seek(sz);
if(d->fileEngine->setSize(sz)) {
unsetError();
d->cachedSize = sz;
return true;
}
d->cachedSize = 0;
d->setError(QFile::ResizeError, d->fileEngine->errorString());
return false;
}
bool
QFile::remove()
{
Q_D(QFile);
if (d->fileName.isEmpty()) {
qWarning("QFile::remove: Empty or null file name");
return false;
}
close();
if(error() == QFile::NoError) {
if(fileEngine()->remove()) {
unsetError();
return true;
}
d->setError(QFile::RemoveError, errno);
}
return false;
}
/*!
Returns the name set by setFileName() or to the QFile
constructors.
\sa setFileName(), QFileInfo::fileName()
*/
QString QFile::fileName() const
{
return fileEngine()->fileName(QAbstractFileEngine::DefaultName);
}
void AndroidAssetsFileEngineHandler::prepopulateCache() const
{
Q_ASSERT(!m_hasTriedPrepopulatingCache);
m_hasTriedPrepopulatingCache = true;
Q_ASSERT(m_assetsCache.isEmpty());
// Failsafe: Don't read cache files that are larger than 1MB
static qint64 maxPrepopulatedCacheSize = qMax(1024LL * 1024LL,
qgetenv("QT_ANDROID_MAX_PREPOPULATED_ASSETS_CACHE_SIZE").toLongLong());
const char *fileName = "--Added-by-androiddeployqt--/qt_cache_pregenerated_file_list";
AAsset *asset = AAssetManager_open(m_assetManager, fileName, AASSET_MODE_BUFFER);
if (asset) {
m_hasPrepopulatedCache = true;
AndroidAbstractFileEngine fileEngine(asset, QString::fromLatin1(fileName));
if (fileEngine.open(QIODevice::ReadOnly)) {
qint64 size = fileEngine.size();
if (size <= maxPrepopulatedCacheSize) {
QByteArray bytes(size, Qt::Uninitialized);
qint64 read = fileEngine.read(bytes.data(), size);
if (read != size) {
qWarning("Failed to read prepopulated cache");
return;
}
QDataStream stream(&bytes, QIODevice::ReadOnly);
stream.setVersion(QDataStream::Qt_5_3);
if (stream.status() != QDataStream::Ok) {
qWarning("Failed to read prepopulated cache");
return;
}
while (!stream.atEnd()) {
QString directoryName;
stream >> directoryName;
int fileCount;
stream >> fileCount;
QVector<QString> fileList;
fileList.reserve(fileCount);
while (fileCount--) {
QString fileName;
stream >> fileName;
fileList.append(fileName);
}
QSharedPointer<AndroidAssetDir> *aad = new QSharedPointer<AndroidAssetDir>(new AndroidAssetDir(0));
(*aad)->m_items = fileList;
// Cost = 0, because we should always cache everything if there's a prepopulated cache
QByteArray key = directoryName != QLatin1String("/")
? QByteArray("assets:/") + directoryName.toUtf8()
: QByteArray("assets:");
bool ok = m_assetsCache.insert(key, aad, 0);
if (!ok)
qWarning("Failed to insert in cache: %s", qPrintable(directoryName));
}
} else {
bool
QFile::copy(const QString &newName)
{
Q_D(QFile);
if (d->fileName.isEmpty()) {
qWarning("QFile::copy: Empty or null file name");
return false;
}
if (QFile(newName).exists()) {
// ### Race condition. If a file is moved in after this, it /will/ be
// overwritten. On Unix, the proper solution is to use hardlinks:
// return ::link(old, new) && ::remove(old); See also rename().
d->setError(QFile::CopyError, QLatin1String("Destination file exists"));
return false;
}
close();
if(error() == QFile::NoError) {
if(fileEngine()->copy(newName)) {
unsetError();
return true;
} else {
bool error = false;
if(!open(QFile::ReadOnly)) {
error = true;
QString errorMessage = QLatin1String("Cannot open %1 for input");
d->setError(QFile::CopyError, errorMessage.arg(d->fileName));
} else {
QString fileTemplate = QLatin1String("%1/qt_temp.XXXXXX");
#ifdef QT_NO_TEMPORARYFILE
QFile out(fileTemplate.arg(QFileInfo(newName).path()));
if (!out.open(QIODevice::ReadWrite))
error = true;
#else
QTemporaryFile out(fileTemplate.arg(QFileInfo(newName).path()));
if (!out.open()) {
out.setFileTemplate(fileTemplate.arg(QDir::tempPath()));
if (!out.open())
error = true;
}
#endif
if (error) {
out.close();
d->setError(QFile::CopyError, QLatin1String("Cannot open for output"));
} else {
char block[4096];
qint64 totalRead = 0;
while(!atEnd()) {
qint64 in = read(block, sizeof(block));
if (in <= 0)
break;
totalRead += in;
if(in != out.write(block, in)) {
d->setError(QFile::CopyError, QLatin1String("Failure to write block"));
error = true;
break;
}
}
if (totalRead != size()) {
// Unable to read from the source. The error string is
// already set from read().
error = true;
}
if (!error && !out.rename(newName)) {
error = true;
QString errorMessage = QLatin1String("Cannot create %1 for output");
d->setError(QFile::CopyError, errorMessage.arg(newName));
}
#ifndef QT_NO_TEMPORARYFILE
if (!error)
out.setAutoRemove(false);
#endif
}
}
if(!error) {
QFile::setPermissions(newName, permissions());
unsetError();
return true;
}
}
}
return false;
}
QFile::Permissions
QFile::permissions() const
{
QAbstractFileEngine::FileFlags perms = fileEngine()->fileFlags(QAbstractFileEngine::PermsMask) & QAbstractFileEngine::PermsMask;
return QFile::Permissions((int)perms); //ewww
}
/*!
\obsolete
Use symLinkTarget() instead.
*/
QString
QFile::readLink() const
{
return fileEngine()->fileName(QAbstractFileEngine::LinkName);
}
