1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
|
// Copyright (C) 2021 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
#ifndef QRINGBUFFER_P_H
#define QRINGBUFFER_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/private/qglobal_p.h>
#include <QtCore/qbytearray.h>
#include <QtCore/qlist.h>
QT_BEGIN_NAMESPACE
#ifndef QRINGBUFFER_CHUNKSIZE
#define QRINGBUFFER_CHUNKSIZE 4096
#endif
class QRingChunk
{
public:
// initialization and cleanup
QRingChunk() noexcept = default;
explicit inline QRingChunk(qsizetype alloc) :
chunk(alloc, Qt::Uninitialized), tailOffset(0)
{
}
explicit inline QRingChunk(const QByteArray &qba) noexcept :
chunk(qba), tailOffset(qba.size())
{
}
explicit QRingChunk(QByteArray &&qba) noexcept :
chunk(std::move(qba)), tailOffset(chunk.size())
{
}
inline void swap(QRingChunk &other) noexcept
{
chunk.swap(other.chunk);
qSwap(headOffset, other.headOffset);
qSwap(tailOffset, other.tailOffset);
}
// allocating and sharing
void allocate(qsizetype alloc);
inline bool isShared() const
{
return !chunk.isDetached();
}
Q_CORE_EXPORT void detach();
QByteArray toByteArray() &&;
// getters
inline qsizetype head() const
{
return headOffset;
}
inline qsizetype size() const
{
return tailOffset - headOffset;
}
inline qsizetype capacity() const
{
return chunk.size();
}
inline qsizetype available() const
{
return chunk.size() - tailOffset;
}
inline const char *data() const
{
return chunk.constData() + headOffset;
}
inline char *data()
{
if (isShared())
detach();
return chunk.data() + headOffset;
}
// array management
inline void advance(qsizetype offset)
{
Q_ASSERT(headOffset + offset >= 0);
Q_ASSERT(size() - offset > 0);
headOffset += offset;
}
inline void grow(qsizetype offset)
{
Q_ASSERT(size() + offset > 0);
Q_ASSERT(head() + size() + offset <= capacity());
tailOffset += offset;
}
inline void assign(const QByteArray &qba)
{
chunk = qba;
headOffset = 0;
tailOffset = qba.size();
}
void assign(QByteArray &&qba)
{
chunk = std::move(qba);
headOffset = 0;
tailOffset = chunk.size();
}
inline void reset()
{
headOffset = tailOffset = 0;
}
inline void clear()
{
*this = {};
}
private:
QByteArray chunk;
qsizetype headOffset = 0;
qsizetype tailOffset = 0;
};
Q_DECLARE_SHARED(QRingChunk)
class QRingBuffer
{
Q_DISABLE_COPY(QRingBuffer)
public:
explicit inline QRingBuffer(int growth = QRINGBUFFER_CHUNKSIZE) :
bufferSize(0), basicBlockSize(growth) { }
QRingBuffer(QRingBuffer &&) noexcept = default;
QRingBuffer &operator=(QRingBuffer &&) noexcept = default;
inline void setChunkSize(int size) {
basicBlockSize = size;
}
inline int chunkSize() const {
return basicBlockSize;
}
inline qint64 nextDataBlockSize() const {
return bufferSize == 0 ? Q_INT64_C(0) : buffers.first().size();
}
inline const char *readPointer() const {
return bufferSize == 0 ? nullptr : buffers.first().data();
}
Q_CORE_EXPORT const char *readPointerAtPosition(qint64 pos, qint64 &length) const;
Q_CORE_EXPORT void free(qint64 bytes);
Q_CORE_EXPORT char *reserve(qint64 bytes);
Q_CORE_EXPORT char *reserveFront(qint64 bytes);
inline void truncate(qint64 pos) {
Q_ASSERT(pos >= 0 && pos <= size());
chop(size() - pos);
}
Q_CORE_EXPORT void chop(qint64 bytes);
inline bool isEmpty() const {
return bufferSize == 0;
}
inline int getChar() {
if (isEmpty())
return -1;
char c = *readPointer();
free(1);
return int(uchar(c));
}
inline void putChar(char c) {
char *ptr = reserve(1);
*ptr = c;
}
void ungetChar(char c)
{
char *ptr = reserveFront(1);
*ptr = c;
}
inline qint64 size() const {
return bufferSize;
}
Q_CORE_EXPORT void clear();
inline qint64 indexOf(char c) const { return indexOf(c, size()); }
Q_CORE_EXPORT qint64 indexOf(char c, qint64 maxLength, qint64 pos = 0) const;
Q_CORE_EXPORT qint64 read(char *data, qint64 maxLength);
Q_CORE_EXPORT QByteArray read();
Q_CORE_EXPORT qint64 peek(char *data, qint64 maxLength, qint64 pos = 0) const;
Q_CORE_EXPORT void append(const char *data, qint64 size);
Q_CORE_EXPORT void append(const QByteArray &qba);
Q_CORE_EXPORT void append(QByteArray &&qba);
inline qint64 skip(qint64 length) {
qint64 bytesToSkip = qMin(length, bufferSize);
free(bytesToSkip);
return bytesToSkip;
}
Q_CORE_EXPORT qint64 readLine(char *data, qint64 maxLength);
inline bool canReadLine() const {
return indexOf('\n') >= 0;
}
private:
QList<QRingChunk> buffers;
qint64 bufferSize;
int basicBlockSize;
};
Q_DECLARE_TYPEINFO(QRingBuffer, Q_RELOCATABLE_TYPE);
QT_END_NAMESPACE
#endif // QRINGBUFFER_P_H
|
