qrandomaccessasyncfile.cpp

Go to the documentation of this file.

// Copyright (C) 2025 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
// Qt-Security score:significant reason:default
 
#include "qrandomaccessasyncfile_p.h"
#include "qrandomaccessasyncfile_p_p.h"
 
QT_BEGIN_NAMESPACE
 
QRandomAccessAsyncFileBackend::QRandomAccessAsyncFileBackend(QRandomAccessAsyncFile *owner)
    : m_owner(owner)
{
}
QRandomAccessAsyncFileBackend::~QRandomAccessAsyncFileBackend() = default;
QRandomAccessAsyncFilePrivate::QRandomAccessAsyncFilePrivate() = default;
QRandomAccessAsyncFilePrivate::~QRandomAccessAsyncFilePrivate() = default;
 
void QRandomAccessAsyncFilePrivate::init()
{
    Q_Q(QRandomAccessAsyncFile);
 
#if defined(QT_RANDOMACCESSASYNCFILE_QIORING) || defined(Q_OS_DARWIN)
    m_backend = std::make_unique<QRandomAccessAsyncFileNativeBackend>(q);
#endif
    if (!m_backend || !m_backend->init()) {
#if QT_CONFIG(thread) && QT_CONFIG(future)
        m_backend = std::make_unique<QRandomAccessAsyncFileThreadPoolBackend>(q);
        [[maybe_unused]]
        bool result = m_backend->init();
        Q_ASSERT(result); // it always succeeds
#endif
    }
}
 
QRandomAccessAsyncFile::QRandomAccessAsyncFile(QObject *parent)
    : QObject{*new QRandomAccessAsyncFilePrivate, parent}
{
    d_func()->init();
}
 
QRandomAccessAsyncFile::~QRandomAccessAsyncFile()
{
    close();
}
 
void QRandomAccessAsyncFile::close()
{
    Q_D(QRandomAccessAsyncFile);
    d->close();
}
 
qint64 QRandomAccessAsyncFile::size() const
{
    Q_D(const QRandomAccessAsyncFile);
    return d->size();
}
 
/*!
    \internal
 
    Attempts to open the file \a filePath with mode \a mode.
 
    \include qrandomaccessasyncfile.cpp returns-qiooperation
*/
QIOOperation *QRandomAccessAsyncFile::open(const QString &filePath, QIODeviceBase::OpenMode mode)
{
    Q_D(QRandomAccessAsyncFile);
    return d->open(filePath, mode);
}
 
/*!
    \internal
 
    Flushes any buffered data to the file.
 
    \include qrandomaccessasyncfile.cpp returns-qiooperation
*/
QIOOperation *QRandomAccessAsyncFile::flush()
{
    Q_D(QRandomAccessAsyncFile);
    return d->flush();
}
 
/*!
    \internal
 
    Reads at maximum \a maxSize bytes, starting from \a offset.
 
    The data is written to the internal buffer managed by the returned
    QIOOperation object.
 
//! [returns-qiooperation]
    Returns a QIOOperation object that would emit a QIOOperation::finished()
    signal once the operation is complete.
//! [returns-qiooperation]
*/
QIOReadOperation *QRandomAccessAsyncFile::read(qint64 offset, qint64 maxSize)
{
    Q_D(QRandomAccessAsyncFile);
    if (maxSize < 0) {
        qWarning("Using a negative maxSize in QRandomAccessAsyncFile::read() is incorrect. "
                 "Resetting to zero!");
        maxSize = 0;
    }
    return d->read(offset, maxSize);
}
 
/*!
    \internal
    \overload
 
    Reads the data from the file, starting from \a offset, and stores it into
    \a buffer.
 
    The amount of bytes to be read from the file is determined by the size of
    the buffer. Note that the actual amount of read bytes can be less than that.
 
    This operation does not take ownership of the provided buffer, so it is the
    user's responsibility to make sure that the buffer is valid until the
    returned QIOOperation completes.
 
    \note The buffer might be populated from different threads, so the user
    application should not access it until the returned QIOOperation completes.
 
    \include qrandomaccessasyncfile.cpp returns-qiooperation
*/
QIOVectoredReadOperation *
QRandomAccessAsyncFile::readInto(qint64 offset, QSpan<std::byte> buffer)
{
    Q_D(QRandomAccessAsyncFile);
    return d->readInto(offset, buffer);
}
 
/*!
    \internal
 
    Reads the data from the file, starting from \a offset, and stores it into
    \a buffers.
 
    The amount of bytes to be read from the file is determined by the sum of
    sizes of all buffers. Note that the actual amount of read bytes can be less
    than that.
 
    This operation does not take ownership of the provided buffers, so it is the
    user's responsibility to make sure that the buffers are valid until the
    returned QIOOperation completes.
 
    \note The buffers might be populated from different threads, so the user
    application should not access them until the returned QIOOperation completes.
 
    \include qrandomaccessasyncfile.cpp returns-qiooperation
*/
QIOVectoredReadOperation *
QRandomAccessAsyncFile::readInto(qint64 offset, QSpan<const QSpan<std::byte>> buffers)
{
    Q_D(QRandomAccessAsyncFile);
    return d->readInto(offset, buffers);
}
 
/*!
    \internal
 
    Writes \a data into the file, starting from \a offset.
 
    The \a data array is copied into the returned QIOOperation object.
 
    \include qrandomaccessasyncfile.cpp returns-qiooperation
*/
QIOWriteOperation *QRandomAccessAsyncFile::write(qint64 offset, const QByteArray &data)
{
    Q_D(QRandomAccessAsyncFile);
    return d->write(offset, data);
}
 
/*!
    \internal
    \overload
 
    Writes \a data into the file, starting from \a offset.
 
    The \a data array is moved into the returned QIOOperation object.
 
    \include qrandomaccessasyncfile.cpp returns-qiooperation
*/
QIOWriteOperation *QRandomAccessAsyncFile::write(qint64 offset, QByteArray &&data)
{
    Q_D(QRandomAccessAsyncFile);
    return d->write(offset, std::move(data));
}
 
/*!
    \internal
    \overload
 
    Writes the content of \a buffer into the file, starting from \a offset.
 
    This operation does not take ownership of the provided buffer, so it is the
    user's responsibility to make sure that the buffer is valid until the
    returned QIOOperation completes.
 
    \note The buffer might be accessed from different threads, so the user
    application should not modify it until the returned QIOOperation completes.
*/
QIOVectoredWriteOperation *
QRandomAccessAsyncFile::writeFrom(qint64 offset, QSpan<const std::byte> buffer)
{
    Q_D(QRandomAccessAsyncFile);
    return d->writeFrom(offset, buffer);
}
 
/*!
    \internal
 
    Writes the content of \a buffers into the file, starting from \a offset.
 
    This operation does not take ownership of the provided buffers, so it is the
    user's responsibility to make sure that the buffers are valid until the
    returned QIOOperation completes.
 
    \note The buffers might be accessed from different threads, so the user
    application should not modify them until the returned QIOOperation
    completes.
*/
QIOVectoredWriteOperation *
QRandomAccessAsyncFile::writeFrom(qint64 offset, QSpan<const QSpan<const std::byte>> buffers)
{
    Q_D(QRandomAccessAsyncFile);
    return d->writeFrom(offset, buffers);
}
 
QT_END_NAMESPACE
 
#include "moc_qrandomaccessasyncfile_p.cpp"