/
EnumeratedArray.h
275 lines (225 loc) · 7.17 KB
/
EnumeratedArray.h
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
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
/*
* Copyright (C) 2022 Apple Inc. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
* OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#pragma once
#include <array>
namespace WTF {
// This is an std::array where the indices of the array are values of an enum (rather than a size_t).
// This assumes the values of the enum start at 0 and monotonically increase by 1
// (so the conversion function between size_t and the enum is just a simple static_cast).
// LastValue is the maximum value of the enum, which determines the size of the array.
template <typename Key, typename T, Key LastValue>
class EnumeratedArray {
WTF_MAKE_FAST_ALLOCATED;
public:
using value_type = T;
using size_type = Key;
using reference = value_type&;
using const_reference = const value_type&;
using pointer = value_type*;
using const_pointer = const value_type*;
private:
// We add 1 to the size because we expect that LastValue is the maximum value of the enum,
// rather than the count of items in the enum.
// We're assuming the values in the enum are zero-indexed.
using UnderlyingType = std::array<T, static_cast<std::size_t>(LastValue) + 1>;
public:
using iterator = typename UnderlyingType::iterator;
using const_iterator = typename UnderlyingType::const_iterator;
using reverse_iterator = std::reverse_iterator<iterator>;
using const_reverse_iterator = std::reverse_iterator<const_iterator>;
EnumeratedArray() = default;
EnumeratedArray(const EnumeratedArray& from)
: m_storage(from.m_storage)
{
}
EnumeratedArray(EnumeratedArray&& from)
: m_storage(WTFMove(from.m_storage))
{
}
EnumeratedArray(const UnderlyingType& from)
: m_storage(from)
{
}
EnumeratedArray(UnderlyingType&& from)
: m_storage(WTFMove(from))
{
}
EnumeratedArray& operator=(const EnumeratedArray& from)
{
m_storage = from.m_storage;
return *this;
}
EnumeratedArray& operator=(EnumeratedArray&& from)
{
m_storage = WTFMove(from.m_storage);
return *this;
}
constexpr reference at(size_type pos)
{
return m_storage.at(index(pos));
}
constexpr const_reference at(size_type pos) const
{
return m_storage.at(index(pos));
}
constexpr reference operator[](size_type pos)
{
return m_storage[index(pos)];
}
constexpr const_reference operator[](size_type pos) const
{
return m_storage[index(pos)];
}
constexpr reference front()
{
return m_storage.front();
}
constexpr const_reference front() const
{
return m_storage.front();
}
constexpr reference back()
{
return m_storage.back();
}
constexpr const_reference back() const
{
return m_storage.back();
}
constexpr T* data() noexcept
{
return m_storage.data();
}
constexpr const T* data() const noexcept
{
return m_storage.data();
}
constexpr iterator begin() noexcept
{
return m_storage.begin();
}
constexpr const_iterator begin() const noexcept
{
return m_storage.begin();
}
constexpr const_iterator cbegin() const noexcept
{
return m_storage.cbegin();
}
constexpr iterator end() noexcept
{
return m_storage.end();
}
constexpr const_iterator end() const noexcept
{
return m_storage.end();
}
constexpr const_iterator cend() const noexcept
{
return m_storage.cend();
}
constexpr reverse_iterator rbegin() noexcept
{
return m_storage.rbegin();
}
constexpr const_reverse_iterator rbegin() const noexcept
{
return m_storage.rbegin();
}
constexpr const_reverse_iterator crbegin() const noexcept
{
return m_storage.crbegin();
}
constexpr reverse_iterator rend() noexcept
{
return m_storage.rend();
}
constexpr const_reverse_iterator rend() const noexcept
{
return m_storage.rend();
}
constexpr const_reverse_iterator crend() const noexcept
{
return m_storage.crend();
}
constexpr bool empty() const noexcept
{
return m_storage.empty();
}
constexpr typename UnderlyingType::size_type size() const noexcept
{
return m_storage.size();
}
constexpr typename UnderlyingType::size_type max_size() const noexcept
{
return m_storage.max_size();
}
constexpr void fill(const T& value)
{
m_storage.fill(value);
}
constexpr void swap(EnumeratedArray& other) noexcept
{
return m_storage.swap(other.m_storage);
}
template <typename Key2, typename T2, Key2 LastValue2>
constexpr bool operator==(const EnumeratedArray<Key2, T2, LastValue2>& rhs) const
{
return m_storage == rhs.m_storage;
}
template <typename Key2, typename T2, Key2 LastValue2>
bool operator!=(const EnumeratedArray<Key2, T2, LastValue2>& rhs) const
{
return m_storage != rhs.m_storage;
}
template <typename Key2, typename T2, Key2 LastValue2>
bool operator<(const EnumeratedArray<Key2, T2, LastValue2>& rhs) const
{
return m_storage < rhs.m_storage;
}
template <typename Key2, typename T2, Key2 LastValue2>
bool operator<=(const EnumeratedArray<Key2, T2, LastValue2>& rhs) const
{
return m_storage <= rhs.m_storage;
}
template <typename Key2, typename T2, Key2 LastValue2>
bool operator>(const EnumeratedArray<Key2, T2, LastValue2>& rhs) const
{
return m_storage > rhs.m_storage;
}
template <typename Key2, typename T2, Key2 LastValue2>
bool operator>=(const EnumeratedArray<Key2, T2, LastValue2>& rhs) const
{
return m_storage >= rhs.m_storage;
}
private:
typename UnderlyingType::size_type index(size_type pos)
{
return static_cast<typename UnderlyingType::size_type>(pos);
}
UnderlyingType m_storage;
};
} // namespace WTF
using WTF::EnumeratedArray;