qnoncontiguousbytedevice_p.h

Enable keyboard shortcuts

// Copyright (C) 2016 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 QNONCONTIGUOUSBYTEDEVICE_P_H

#define QNONCONTIGUOUSBYTEDEVICE_P_H

//

//  W A R N I N G

//  -------------

//

// This file is not part of the Qt API.  It exists for the convenience

// of a number of Qt sources files.  This header file may change from

// version to version without notice, or even be removed.

//

// We mean it.

//

#include <QtCore/qobject.h>

#include <QtCore/qbytearray.h>

#include <QtCore/qbuffer.h>

#include <QtCore/qiodevice.h>

#include "private/qringbuffer_p.h"

#include <memory>

QT_BEGIN_NAMESPACE

class Q_CORE_EXPORT QNonContiguousByteDevice : public QObject

    Q_OBJECT

public:

    virtual const char *readPointer(qint64 maximumLength, qint64 &len) = 0;

    virtual bool advanceReadPointer(qint64 amount) = 0;

    virtual bool atEnd() const = 0;

    virtual qint64 pos() const { return -1; }

    virtual bool reset() = 0;

    virtual qint64 size() const = 0;

    virtual ~QNonContiguousByteDevice();

protected:

    QNonContiguousByteDevice();

Q_SIGNALS:

    void readyRead();

    void readProgress(qint64 current, qint64 total);

};

class Q_CORE_EXPORT QNonContiguousByteDeviceFactory

public:

    static QNonContiguousByteDevice *create(QIODevice *device);

    static std::shared_ptr<QNonContiguousByteDevice> createShared(QIODevice *device);

    static QNonContiguousByteDevice *create(const QByteArray &byteArray);

    static std::shared_ptr<QNonContiguousByteDevice> createShared(const QByteArray &byteArray);

    static QNonContiguousByteDevice *create(std::shared_ptr<QRingBuffer> ringBuffer);

    static std::shared_ptr<QNonContiguousByteDevice> createShared(std::shared_ptr<QRingBuffer> ringBuffer);

    static QIODevice *wrap(QNonContiguousByteDevice *byteDevice);

};

// the actual implementations

//

class QNonContiguousByteDeviceByteArrayImpl : public QNonContiguousByteDevice

    Q_OBJECT

public:

    explicit QNonContiguousByteDeviceByteArrayImpl(QByteArray ba);

    explicit QNonContiguousByteDeviceByteArrayImpl(QBuffer *buffer);

    ~QNonContiguousByteDeviceByteArrayImpl();

    const char *readPointer(qint64 maximumLength, qint64 &len) override;

    bool advanceReadPointer(qint64 amount) override;

    bool atEnd() const override;

    bool reset() override;

    qint64 size() const override;

    qint64 pos() const override;

protected:

    QByteArray byteArray;

    QByteArrayView view;

    qint64 currentPosition = 0;

};

class QNonContiguousByteDeviceRingBufferImpl : public QNonContiguousByteDevice

    Q_OBJECT

public:

    explicit QNonContiguousByteDeviceRingBufferImpl(std::shared_ptr<QRingBuffer> rb);

    ~QNonContiguousByteDeviceRingBufferImpl();

    const char *readPointer(qint64 maximumLength, qint64 &len) override;

    bool advanceReadPointer(qint64 amount) override;

    bool atEnd() const override;

    bool reset() override;

    qint64 size() const override;

    qint64 pos() const override;

protected:

    std::shared_ptr<QRingBuffer> ringBuffer;

    qint64 currentPosition = 0;

};

class QNonContiguousByteDeviceIoDeviceImpl : public QNonContiguousByteDevice

    Q_OBJECT

public:

    explicit QNonContiguousByteDeviceIoDeviceImpl(QIODevice *d);

    ~QNonContiguousByteDeviceIoDeviceImpl();

    const char *readPointer(qint64 maximumLength, qint64 &len) override;

    bool advanceReadPointer(qint64 amount) override;

    bool atEnd() const override;

    bool reset() override;

    qint64 size() const override;

    qint64 pos() const override;

protected:

    QIODevice *device;

    QByteArray *currentReadBuffer;

    qint64 currentReadBufferSize;

    qint64 currentReadBufferAmount;

    qint64 currentReadBufferPosition;

    qint64 totalAdvancements;

    bool eof;

    qint64 initialPosition;

};

// ... and the reverse thing

class QByteDeviceWrappingIoDevice : public QIODevice

    Q_OBJECT

public:

    explicit QByteDeviceWrappingIoDevice(QNonContiguousByteDevice *bd);

    ~QByteDeviceWrappingIoDevice();

    bool isSequential() const override;

    bool atEnd() const override;

    bool reset() override;

    qint64 size() const override;

protected:

    qint64 readData(char *data, qint64 maxSize) override;

    qint64 writeData(const char *data, qint64 maxSize) override;

    QNonContiguousByteDevice *byteDevice;

};

QT_END_NAMESPACE

#endif