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
|
#pragma once
#include "Base.h"
namespace cru {
class Buffer final {
friend void swap(Buffer& left, Buffer& right) noexcept;
public:
explicit Buffer(Index size);
Buffer(const Buffer& other);
Buffer(Buffer&& other) noexcept;
Buffer& operator=(const Buffer& other);
Buffer& operator=(Buffer&& other) noexcept;
~Buffer();
private:
Index GetBufferSize() const { return size_; }
Index GetUsedSize() const { return used_end_ - used_begin_; }
bool IsNull() const { return ptr_ == nullptr; }
bool IsUsedReachEnd() const { return used_end_ == size_; }
Index GetUsedBegin() const { return used_begin_; }
Index GetUsedEnd() const { return used_end_; }
std::byte* GetPtr() { return GetPtrAt(0); }
const std::byte* GetPtr() const { return GetPtrAt(0); }
std::byte* GetPtrAt(Index index) { return ptr_ + index; }
const std::byte* GetPtrAt(Index index) const { return ptr_ + index; }
std::byte& GetRefAt(Index index) { return *GetPtrAt(index); }
const std::byte& GetRefAt(Index index) const { return *GetPtrAt(index); }
std::byte* GetUsedBeginPtr() { return GetPtrAt(GetUsedBegin()); }
const std::byte* GetUsedBeginPtr() const { return GetPtrAt(GetUsedBegin()); }
std::byte* GetUsedEndPtr() { return GetPtrAt(GetUsedEnd()); }
const std::byte* GetUsedEndPtr() const { return GetPtrAt(GetUsedEnd()); }
std::byte GetByteAt(Index index) const { return ptr_[index]; }
void SetByteAt(Index index, std::byte value) { ptr_[index] = value; }
void AssignBytes(std::byte* src, Index src_size, bool use_memmove = false) {
return AssignBytes(0, src, 0, src_size, use_memmove);
}
void AssignBytes(Index dst_offset, std::byte* src, Index src_size,
bool use_memmove = false) {
return AssignBytes(dst_offset, src, 0, src_size, use_memmove);
}
void AssignBytes(Index dst_offset, std::byte* src, Index src_offset,
Index src_size, bool use_memmove = false);
/**
* @brief Change the size of the buffer.
*
* Unless new size is the same as current size, the buffer is always released
* and a new one is allocated. If preserve_used is true, the used size and old
* data is copied to the new buffer. If new size is smaller than old used
* size, then exceeded data will be lost.
*/
void ResizeBuffer(Index new_size, bool preserve_used);
/**
* @brief Append data to the front of used bytes and increase used size.
* @return The actual size of data saved.
*
* If there is no enough space left for new data, the rest space will be
* written and the size of it will be returned, leaving exceeded data not
* saved.
*/
Index PushFront(std::byte* other, Index other_size, bool use_memmove = false);
/**
* @brief Append data to the back of used bytes and increase used size.
* @return The actual size of data saved.
*
* If there is no enough space left for new data, the rest space will be
* written and the size of it will be returned, leaving exceeded data not
* saved.
*/
Index PushBack(std::byte* other, Index other_size, bool use_memmove = false);
/**
* @brief Move forward the used-begin ptr.
* @return The actual size moved forward.
*
* If given size is bigger than current used size, the used size will be
* returned and set to 0.
*/
Index PopFront(Index size);
/**
* @brief Move backward the used-end ptr.
* @return The actual size moved backward.
*
* If given size is bigger than current used size, the used size will be
* returned and set to 0.
*/
Index PopEnd(Index size);
operator std::byte*() { return GetPtr(); }
operator const std::byte*() const { return GetPtr(); }
private:
void Copy_(const Buffer& other);
void Move_(Buffer&& other) noexcept;
void Delete_() noexcept;
private:
std::byte* ptr_;
Index size_;
Index used_begin_;
Index used_end_;
};
void swap(Buffer& left, Buffer& right) noexcept;
} // namespace cru
|
