blob: b45d5d81df90c79cd9f27677643dcb0e06f0cfd6 (
plain)
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
|
#pragma once
#include "asl/meta.hpp"
#include "asl/allocator.hpp"
#include "asl/annotations.hpp"
#include "asl/memory.hpp"
namespace asl
{
template<is_object T, allocator Allocator = DefaultAllocator>
class buffer
{
T* m_data{};
isize_t m_capacity{};
static constexpr size_t kOnHeapMask = 0x8000'0000'0000'0000ULL;
// bit 63 : 1 = on heap, 0 = inline
// bits [62:56] : size when inline
// bits [62:0] : size when on heap
size_t m_size_encoded_{};
ASL_NO_UNIQUE_ADDRESS Allocator m_allocator;
static_assert(align_of<T> <= align_of<T*>);
static_assert(align_of<T*> == align_of<isize_t>);
static_assert(align_of<T*> == align_of<size_t>);
constexpr size_t load_size_encoded() const
{
size_t s{};
asl::memcpy(&s, &m_size_encoded_, sizeof(size_t));
return s;
}
static constexpr bool is_on_heap(size_t size_encoded)
{
return (size_encoded & kOnHeapMask) != 0;
}
static constexpr isize_t decode_size(size_t size_encoded)
{
if constexpr (kInlineCapacity == 0)
{
return is_on_heap(size_encoded)
? static_cast<isize_t>(size_encoded & (~kOnHeapMask))
: 0;
}
else
{
return is_on_heap(size_encoded)
? static_cast<isize_t>(size_encoded & (~kOnHeapMask))
: static_cast<isize_t>(size_encoded >> 56);
}
}
public:
static constexpr isize_t kInlineCapacity = []() {
// 1 byte is used for size inline in m_size_encoded.
// This is enough because we have at most 24 bytes available,
// so 23 chars of capacity.
const isize_t available_size = size_of<T*> + size_of<isize_t> + size_of<size_t> - 1;
return available_size / size_of<T>;
}();
constexpr buffer() requires default_constructible<Allocator> = default;
explicit constexpr buffer(Allocator allocator)
: m_allocator{ASL_MOVE(allocator)}
{}
constexpr isize_t size() const
{
return decode_size(load_size_encoded());
}
constexpr isize_t capacity() const
{
if constexpr (kInlineCapacity == 0)
{
return m_capacity;
}
else
{
return is_on_heap(load_size_encoded())
? m_capacity
: kInlineCapacity;
}
}
// @Todo(C++23) Use deducing this
const T* data() const
{
if constexpr (kInlineCapacity == 0)
{
return m_data;
}
else
{
return is_on_heap(load_size_encoded())
? m_data
: reinterpret_cast<const T*>(this);
}
}
T* data()
{
if constexpr (kInlineCapacity == 0)
{
return m_data;
}
else
{
return is_on_heap(load_size_encoded())
? m_data
: reinterpret_cast<const T*>(this);
}
}
};
} // namespace asl
|
