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
|
#pragma once
#include "Types.h"
#include "StdLibExtras.h"
#include <AK/Retainable.h>
#include <AK/RetainPtr.h>
#include <AK/kmalloc.h>
namespace AK {
class ByteBufferImpl : public Retainable<ByteBufferImpl> {
public:
static Retained<ByteBufferImpl> create_uninitialized(int size);
static Retained<ByteBufferImpl> create_zeroed(int);
static Retained<ByteBufferImpl> copy(const void*, int);
static Retained<ByteBufferImpl> wrap(void*, int);
static Retained<ByteBufferImpl> adopt(void*, int);
~ByteBufferImpl() { clear(); }
void clear()
{
if (!m_data)
return;
if (m_owned)
kfree(m_data);
m_data = nullptr;
}
byte& operator[](int i) { ASSERT(i < m_size); return m_data[i]; }
const byte& operator[](int i) const { ASSERT(i < m_size); return m_data[i]; }
bool is_empty() const { return !m_size; }
int size() const { return m_size; }
byte* pointer() { return m_data; }
const byte* pointer() const { return m_data; }
byte* offset_pointer(int offset) { return m_data + offset; }
const byte* offset_pointer(int offset) const { return m_data + offset; }
void* end_pointer() { return m_data + m_size; }
const void* end_pointer() const { return m_data + m_size; }
// NOTE: trim() does not reallocate.
void trim(int size)
{
ASSERT(size <= m_size);
m_size = size;
}
void grow(int size);
private:
enum ConstructionMode { Uninitialized, Copy, Wrap, Adopt };
explicit ByteBufferImpl(int); // For ConstructionMode=Uninitialized
ByteBufferImpl(const void*, int, ConstructionMode); // For ConstructionMode=Copy
ByteBufferImpl(void*, int, ConstructionMode); // For ConstructionMode=Wrap/Adopt
ByteBufferImpl() { }
byte* m_data { nullptr };
int m_size { 0 };
bool m_owned { false };
};
class ByteBuffer {
public:
ByteBuffer() { }
ByteBuffer(std::nullptr_t) { }
ByteBuffer(const ByteBuffer& other)
: m_impl(other.m_impl.copy_ref())
{
}
ByteBuffer(ByteBuffer&& other)
: m_impl(move(other.m_impl))
{
}
ByteBuffer& operator=(ByteBuffer&& other)
{
if (this != &other)
m_impl = move(other.m_impl);
return *this;
}
ByteBuffer& operator=(const ByteBuffer& other)
{
m_impl = other.m_impl.copy_ref();
return *this;
}
static ByteBuffer create_uninitialized(ssize_t size) { return ByteBuffer(ByteBufferImpl::create_uninitialized(size)); }
static ByteBuffer create_zeroed(ssize_t size) { return ByteBuffer(ByteBufferImpl::create_zeroed(size)); }
static ByteBuffer copy(const void* data, ssize_t size) { return ByteBuffer(ByteBufferImpl::copy(data, size)); }
static ByteBuffer wrap(void* data, ssize_t size) { return ByteBuffer(ByteBufferImpl::wrap(data, size)); }
static ByteBuffer adopt(void* data, ssize_t size) { return ByteBuffer(ByteBufferImpl::adopt(data, size)); }
~ByteBuffer() { clear(); }
void clear() { m_impl = nullptr; }
operator bool() const { return !is_null(); }
bool operator!() const { return is_null(); }
bool is_null() const { return m_impl == nullptr; }
byte& operator[](ssize_t i) { ASSERT(m_impl); return (*m_impl)[i]; }
byte operator[](ssize_t i) const { ASSERT(m_impl); return (*m_impl)[i]; }
bool is_empty() const { return !m_impl || m_impl->is_empty(); }
ssize_t size() const { return m_impl ? m_impl->size() : 0; }
byte* data() { return pointer(); }
const byte* data() const { return pointer(); }
byte* pointer() { return m_impl ? m_impl->pointer() : nullptr; }
const byte* pointer() const { return m_impl ? m_impl->pointer() : nullptr; }
byte* offset_pointer(ssize_t offset) { return m_impl ? m_impl->offset_pointer(offset) : nullptr; }
const byte* offset_pointer(ssize_t offset) const { return m_impl ? m_impl->offset_pointer(offset) : nullptr; }
void* end_pointer() { return m_impl ? m_impl->end_pointer() : nullptr; }
const void* end_pointer() const { return m_impl ? m_impl->end_pointer() : nullptr; }
// NOTE: trim() does not reallocate.
void trim(ssize_t size)
{
if (m_impl)
m_impl->trim(size);
}
ByteBuffer slice(ssize_t offset, ssize_t size) const
{
if (is_null())
return { };
if (offset >= this->size())
return { };
if (offset + size >= this->size())
size = this->size() - offset;
return copy(offset_pointer(offset), size);
}
void grow(ssize_t size)
{
if (!m_impl)
m_impl = ByteBufferImpl::create_uninitialized(size);
else
m_impl->grow(size);
}
void append(const void* data, int data_size)
{
int old_size = size();
grow(size() + data_size);
memcpy(pointer() + old_size, data, data_size);
}
private:
explicit ByteBuffer(RetainPtr<ByteBufferImpl>&& impl)
: m_impl(move(impl))
{
}
RetainPtr<ByteBufferImpl> m_impl;
};
inline ByteBufferImpl::ByteBufferImpl(int size)
: m_size(size)
{
m_data = static_cast<byte*>(kmalloc(size));
m_owned = true;
}
inline ByteBufferImpl::ByteBufferImpl(const void* data, int size, ConstructionMode mode)
: m_size(size)
{
ASSERT(mode == Copy);
m_data = static_cast<byte*>(kmalloc(size));
memcpy(m_data, data, size);
m_owned = true;
}
inline ByteBufferImpl::ByteBufferImpl(void* data, ssize_t size, ConstructionMode mode)
: m_data(static_cast<byte*>(data))
, m_size(size)
{
if (mode == Adopt) {
m_owned = true;
} else if (mode == Wrap) {
m_owned = false;
}
}
inline void ByteBufferImpl::grow(ssize_t size)
{
ASSERT(size > m_size);
ASSERT(m_owned);
byte* new_data = static_cast<byte*>(kmalloc(size));
memcpy(new_data, m_data, m_size);
byte* old_data = m_data;
m_data = new_data;
m_size = size;
kfree(old_data);
}
inline Retained<ByteBufferImpl> ByteBufferImpl::create_uninitialized(int size)
{
return ::adopt(*new ByteBufferImpl(size));
}
inline Retained<ByteBufferImpl> ByteBufferImpl::create_zeroed(int size)
{
auto buffer = ::adopt(*new ByteBufferImpl(size));
memset(buffer->pointer(), 0, size);
return buffer;
}
inline Retained<ByteBufferImpl> ByteBufferImpl::copy(const void* data, int size)
{
return ::adopt(*new ByteBufferImpl(data, size, Copy));
}
inline Retained<ByteBufferImpl> ByteBufferImpl::wrap(void* data, int size)
{
return ::adopt(*new ByteBufferImpl(data, size, Wrap));
}
inline Retained<ByteBufferImpl> ByteBufferImpl::adopt(void* data, int size)
{
return ::adopt(*new ByteBufferImpl(data, size, Adopt));
}
}
using AK::ByteBuffer;
|
