qtemporarydir.cpp

Go to the documentation of this file.

// Copyright (C) 2017 The Qt Company Ltd.
// Copyright (C) 2017 Intel Corporation.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
 
#include "qtemporarydir.h"
 
#if QT_CONFIG(temporaryfile)
 
#include "qdebug.h"
#include "qplatformdefs.h"
#include "qrandom.h"
#include "private/qtemporaryfile_p.h"
 
#if defined(QT_BUILD_CORE_LIB)
#include "qcoreapplication.h"
#endif
 
#if !defined(Q_OS_WIN)
#include <errno.h>
#endif
 
#include <type_traits>
 
QT_BEGIN_NAMESPACE
 
using namespace Qt::StringLiterals;
 
static_assert(std::is_nothrow_move_constructible_v<QTemporaryDir>);
static_assert(std::is_nothrow_move_assignable_v<QTemporaryDir>);
 
//************* QTemporaryDirPrivate
class QTemporaryDirPrivate
{
public:
    QTemporaryDirPrivate();
    ~QTemporaryDirPrivate();
 
    void create(const QString &templateName);
 
    QString pathOrError;
    bool autoRemove;
    bool success;
};
 
QTemporaryDirPrivate::QTemporaryDirPrivate()
    : autoRemove(true),
      success(false)
{
}
 
QTemporaryDirPrivate::~QTemporaryDirPrivate()
{
}
 
static QString defaultTemplateName()
{
    QString baseName;
#if defined(QT_BUILD_CORE_LIB)
    baseName = QCoreApplication::applicationName();
    if (baseName.isEmpty())
#endif
        baseName = "qt_temp"_L1;
 
    return QDir::tempPath() + u'/' + baseName + "-XXXXXX"_L1;
}
 
void QTemporaryDirPrivate::create(const QString &templateName)
{
    QTemporaryFileName tfn(templateName);
    for (int i = 0; i < 256; ++i) {
        tfn.generateNext();
        QFileSystemEntry fileSystemEntry(tfn.path, QFileSystemEntry::FromNativePath());
        if (QFileSystemEngine::createDirectory(fileSystemEntry, false,
                                               QFile::ReadOwner | QFile::WriteOwner
                                                       | QFile::ExeOwner)) {
            success = true;
            pathOrError = fileSystemEntry.filePath();
            return;
        }
#  ifdef Q_OS_WIN
        const int exists = ERROR_ALREADY_EXISTS;
        int code = GetLastError();
#  else
        const int exists = EEXIST;
        int code = errno;
#  endif
        if (code != exists)
            break;
    }
    pathOrError = qt_error_string();
    success = false;
}
 
//************* QTemporaryDir
 
QTemporaryDir::QTemporaryDir()
    : d_ptr(new QTemporaryDirPrivate)
{
    d_ptr->create(defaultTemplateName());
}
 
QTemporaryDir::QTemporaryDir(const QString &templatePath)
    : d_ptr(new QTemporaryDirPrivate)
{
    if (templatePath.isEmpty())
        d_ptr->create(defaultTemplateName());
    else
        d_ptr->create(templatePath);
}
 
QTemporaryDir::~QTemporaryDir()
{
    if (d_ptr) {
        if (d_ptr->autoRemove)
            remove();
 
        delete d_ptr;
    }
}
 
bool QTemporaryDir::isValid() const
{
    return d_ptr->success;
}
 
QString QTemporaryDir::errorString() const
{
    return d_ptr->success ? QString() : d_ptr->pathOrError;
}
 
QString QTemporaryDir::path() const
{
    return d_ptr->success ? d_ptr->pathOrError : QString();
}
 
QString QTemporaryDir::filePath(const QString &fileName) const
{
    if (QDir::isAbsolutePath(fileName)) {
        qWarning("QTemporaryDir::filePath: Absolute paths are not allowed: %s", qUtf8Printable(fileName));
        return QString();
    }
 
    if (!d_ptr->success)
        return QString();
 
    QString ret = d_ptr->pathOrError;
    if (!fileName.isEmpty()) {
        ret += u'/';
        ret += fileName;
    }
    return ret;
}
 
bool QTemporaryDir::autoRemove() const
{
    return d_ptr->autoRemove;
}
 
void QTemporaryDir::setAutoRemove(bool b)
{
    d_ptr->autoRemove = b;
}
 
bool QTemporaryDir::remove()
{
    if (!d_ptr->success)
        return false;
    Q_ASSERT(!path().isEmpty());
    Q_ASSERT(path() != "."_L1);
 
    const bool result = QDir(path()).removeRecursively();
    if (!result) {
        qWarning() << "QTemporaryDir: Unable to remove"
                   << QDir::toNativeSeparators(path())
                   << "most likely due to the presence of read-only files.";
    }
    return result;
}
 
QT_END_NAMESPACE
 
#endif // QT_CONFIG(temporaryfile)