qiooperation_p_p.h

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
 
#ifndef QIOOPERATION_P_P_H
#define QIOOPERATION_P_P_H
 
//
//  W A R N I N G
//  -------------
//
// This file is not part of the Qt API.  It exists purely as an
// implementation detail.  This header file may change from version to
// version without notice, or even be removed.
//
// We mean it.
//
 
#include "qiooperation_p.h"
#include "qrandomaccessasyncfile_p.h"
 
#include <QtCore/private/qobject_p.h>
 
#include <QtCore/qspan.h>
#include <QtCore/qvarlengtharray.h>
 
#ifdef QT_RANDOMACCESSASYNCFILE_QIORING
#include <QtCore/private/qioring_p.h>
#endif
 
#include <variant>
 
QT_BEGIN_NAMESPACE
 
namespace QtPrivate {
 
class QIOOperationDataStorage
{
public:
    // When passing QSpan<QSpan<T>>, we'd better have an underlying storage
    // for an outer span, so that users could pass in a temporary object.
    // We'd use QVarLengthArray for that. Having 256 elements (the default)
    // seems to be unneeded for vectored IO. For now I picked 10 as a reasonable
    // default. But maybe even less?
    static constexpr qsizetype DefaultNumOfBuffers = 10;
    using ReadSpans = QVarLengthArray<QSpan<std::byte>, DefaultNumOfBuffers>;
    using WriteSpans = QVarLengthArray<QSpan<const std::byte>, DefaultNumOfBuffers>;
 
    explicit QIOOperationDataStorage()
        : data(std::monostate{})
    {}
    explicit QIOOperationDataStorage(QSpan<const QSpan<std::byte>> s)
        : data(ReadSpans(s.begin(), s.end()))
    {}
    explicit QIOOperationDataStorage(QSpan<const QSpan<const std::byte>> s)
        : data(WriteSpans(s.begin(), s.end()))
    {}
    explicit QIOOperationDataStorage(const QByteArray &a)
        : data(a)
    {}
    explicit QIOOperationDataStorage(QByteArray &&a)
        : data(std::move(a))
    {}
 
    bool isEmpty() const
    { return std::holds_alternative<std::monostate>(data); }
 
    bool containsReadSpans() const
    { return std::holds_alternative<ReadSpans>(data); }
 
    bool containsWriteSpans() const
    { return std::holds_alternative<WriteSpans>(data); }
 
    bool containsByteArray() const
    { return std::holds_alternative<QByteArray>(data); }
 
    ReadSpans &getReadSpans()
    {
        Q_ASSERT(containsReadSpans());
        return *std::get_if<ReadSpans>(&data);
    }
    const ReadSpans &getReadSpans() const
    {
        Q_ASSERT(containsReadSpans());
        return *std::get_if<ReadSpans>(&data);
    }
 
    WriteSpans &getWriteSpans()
    {
        Q_ASSERT(containsWriteSpans());
        return *std::get_if<WriteSpans>(&data);
    }
    const WriteSpans &getWriteSpans() const
    {
        Q_ASSERT(containsWriteSpans());
        return *std::get_if<WriteSpans>(&data);
    }
 
    QByteArray &getByteArray()
    {
        Q_ASSERT(containsByteArray());
        return *std::get_if<QByteArray>(&data);
    }
    const QByteArray &getByteArray() const
    {
        Q_ASSERT(containsByteArray());
        return *std::get_if<QByteArray>(&data);
    }
 
    // Potentially can be extended to return a QVariant::value<T>().
    template <typename T>
    T getValue() const = delete;
 
private:
    std::variant<std::monostate, ReadSpans, WriteSpans, QByteArray> data;
};
 
template <>
inline QSpan<const QSpan<std::byte>> QIOOperationDataStorage::getValue() const
{
    Q_ASSERT(std::holds_alternative<ReadSpans>(data));
    const auto *val = std::get_if<ReadSpans>(&data);
    if (val)
        return QSpan(*val);
    return {};
}
 
template <>
inline QSpan<const QSpan<const std::byte>> QIOOperationDataStorage::getValue() const
{
    Q_ASSERT(std::holds_alternative<WriteSpans>(data));
    const auto *val = std::get_if<WriteSpans>(&data);
    if (val)
        return QSpan(*val);
    return {};
}
 
template <>
inline QByteArray QIOOperationDataStorage::getValue() const
{
    Q_ASSERT(std::holds_alternative<QByteArray>(data));
    const auto *val = std::get_if<QByteArray>(&data);
    if (val)
        return *val;
    return {};
}
 
} // namespace QtPrivate
 
class QIOOperationPrivate : public QObjectPrivate
{
public:
    Q_DECLARE_PUBLIC(QIOOperation)
 
    enum class State : quint8
    {
        Running,
        Finished,
    };
 
    explicit QIOOperationPrivate(QtPrivate::QIOOperationDataStorage *storage);
    ~QIOOperationPrivate();
 
    static QIOOperationPrivate *get(QIOOperation *op)
    { return op->d_func(); }
 
    void appendBytesProcessed(qint64 num);
    void operationComplete(QIOOperation::Error err);
    void setError(QIOOperation::Error err);
 
    QPointer<QRandomAccessAsyncFile> file;
 
    qint64 offset = 0;
    qint64 processed = 0;
 
    QIOOperation::Error error = QIOOperation::Error::None;
    QIOOperation::Type type = QIOOperation::Type::Unknown;
 
    State state = State::Running;
 
    // takes ownership
    std::unique_ptr<QtPrivate::QIOOperationDataStorage> dataStorage;
};
 
QT_END_NAMESPACE
 
#endif // QIOOPERATION_P_P_H