qiooperation_p_p.h

Enable keyboard shortcuts

// 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