+
+
+
+
+
+
+
+
+
+
+
+
+
+
15 #ifndef BELUGA_CONTAINERS_CIRCULAR_ARRAY_HPP
+
16 #define BELUGA_CONTAINERS_CIRCULAR_ARRAY_HPP
+
+
+
+
+
+
22 #include <type_traits>
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
48 static_cast<typename std::underlying_type<CircularArrayFeatureFlags>::type
>(lflag) |
+
49 static_cast<typename std::underlying_type<CircularArrayFeatureFlags>::type
>(rflag));
+
+
+
+
54 return static_cast<bool>(
+
55 static_cast<typename std::underlying_type<CircularArrayFeatureFlags>::type
>(mask) &
+
56 static_cast<typename std::underlying_type<CircularArrayFeatureFlags>::type
>(flag));
+
+
+
+
75 template <
typename T, std::
size_t N, CircularArrayFeatureFlags F = CircularArrayFeatureFlags::kNone>
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
125 typename = std::enable_if_t<std::is_same_v<T, typename std::iterator_traits<Iterator>::value_type>>>
+
+
127 if constexpr (F & CircularArrayFeatureFlags::kLayoutReversal) {
+
+
129 for (size_ = 0; size_ < N && first != last; ++size_, ++first) {
+
130 data_[tail_index_ - size_] = *first;
+
+
132 if constexpr (!(F & CircularArrayFeatureFlags::kRolloverOnWrite)) {
+
+
134 throw std::length_error{
"Range does not fit in circular array"};
+
+
+
+
138 const auto n =
static_cast<size_type>(std::distance(first, last));
+
+
140 if constexpr (!(F & CircularArrayFeatureFlags::kRolloverOnWrite)) {
+
141 throw std::length_error{
"Range does not fit in circular array"};
+
+
143 std::advance(first, n - N);
+
+
+
146 for (size_ = 0; size_ < N && first != last; ++size_, ++first) {
+
147 data_[size_] = *first;
+
+
149 tail_index_ = size_ - 1;
+
+
+
+
+
162 template <std::
size_t M,
typename = std::enable_if_t<M >= 1 && M <= N>>
+
+
164 if constexpr (F & CircularArrayFeatureFlags::kLayoutReversal) {
+
165 for (std::size_t i = 0; i < M; ++i)
+
166 data_[i] =
data[M - i - 1];
+
+
168 for (std::size_t i = 0; i < M; ++i)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
208 template <
bool Enabled = !(F & CircularArrayFeatureFlags::kLayoutReversal)>
+
+
+
211 !(F & CircularArrayFeatureFlags::kLayoutReversal),
+
212 "Cannot push_back() when the layout reversal feature is enabled.");
+
213 if constexpr (!(F & CircularArrayFeatureFlags::kRolloverOnWrite)) {
+
+
215 throw std::length_error{
"Circular array reached its maximum size"};
+
+
+
218 if (++tail_index_ == N)
+
+
220 data_[tail_index_] = std::move(value);
+
221 size_ = std::min(size_ + 1, N);
+
+
+
+
231 template <
bool Enabled = F& CircularArrayFeatureFlags::kLayoutReversal>
+
+
+
234 F & CircularArrayFeatureFlags::kLayoutReversal,
+
235 "Cannot push_front() when the layout reversal feature is not enabled.");
+
236 if constexpr (!(F & CircularArrayFeatureFlags::kRolloverOnWrite)) {
+
+
238 throw std::length_error{
"Circular array reached its maximum size"};
+
+
+
241 if (++tail_index_ == N)
+
+
243 data_[tail_index_] = std::move(value);
+
244 size_ = std::min(size_ + 1, N);
+
+
+
+
253 template <
bool Enabled = F& CircularArrayFeatureFlags::kLayoutReversal>
+
+
+
+
+
+
264 template <
bool Enabled = !(F & CircularArrayFeatureFlags::kLayoutReversal)>
+
+
+
+
+
+
+
274 if constexpr (F & CircularArrayFeatureFlags::kLayoutReversal) {
+
275 return data_[head_index()];
+
+
277 return data_[tail_index_];
+
+
+
+
+
285 if constexpr (F & CircularArrayFeatureFlags::kLayoutReversal) {
+
286 return data_[head_index()];
+
+
288 return data_[tail_index_];
+
+
+
+
+
+
297 if constexpr (F & CircularArrayFeatureFlags::kLayoutReversal) {
+
298 return data_[tail_index_];
+
+
300 return data_[head_index()];
+
+
+
+
+
+
309 if constexpr (F & CircularArrayFeatureFlags::kLayoutReversal) {
+
310 return data_[tail_index_];
+
+
312 return data_[head_index()];
+
+
+
+
+
+
+
322 throw std::out_of_range{
"Index out of circular array range"};
+
+
324 return (*
this)[index];
+
+
+
+
+
+
333 throw std::out_of_range{
"Index out of circular array range"};
+
+
335 return (*
this)[index];
+
+
+
+
+
343 if constexpr (F & CircularArrayFeatureFlags::kLayoutReversal) {
+
344 return data_[
static_cast<size_type>(index > tail_index_) * N + tail_index_ - index];
+
+
346 return data_[
static_cast<size_type>(size_ - index > tail_index_ + 1) * N + tail_index_ - (size_ - index - 1)];
+
+
+
+
+
+
355 if constexpr (F & CircularArrayFeatureFlags::kExtrapolateOnRead) {
+
356 index = std::min(index, size_ - 1);
+
+
358 if constexpr (F & CircularArrayFeatureFlags::kLayoutReversal) {
+
359 return data_[
static_cast<size_type>(index > tail_index_) * N + tail_index_ - index];
+
+
361 return data_[
static_cast<size_type>(size_ - index > tail_index_ + 1) * N + tail_index_ - (size_ - index - 1)];
+
+
+
+
+
+
+
374 tail_index_ = (tail_index_ + 1) % N;
+
375 data_[tail_index_] = value;
+
+
+
+
+
+
384 void clear() noexcept { size_ = 0; }
+
+
+
392 template <CircularArrayFeatureFlags G>
+
+
+
395 swap(data_, other.data_);
+
396 swap(size_, other.size_);
+
397 swap(tail_index_, other.tail_index_);
+
+
+
400 template <
typename U, std::
size_t M, CircularArrayFeatureFlags G>
+
+
+
+
408 [[nodiscard]] constexpr T*
data() noexcept {
return data_.data(); }
+
+
+
415 [[nodiscard]] constexpr
const T*
data() const noexcept {
return data_.data(); }
+
+
418 [[nodiscard]] constexpr
bool full() const noexcept {
return size_ == N; }
+
+
421 [[nodiscard]] constexpr
bool empty() const noexcept {
return size_ == 0U; }
+
+
+
+
+
+
+
+
437 if constexpr (F & CircularArrayFeatureFlags::kExtrapolateOnRead) {
+
438 return static_cast<size_type>(size_ > 0) * N;
+
+
+
+
+
+
+
+
446 [[nodiscard]] constexpr
size_type head_index() const noexcept {
+
447 return static_cast<size_type>(size_ > tail_index_ + 1) * N + tail_index_ - size_ + 1;
+
+
+
450 std::array<T, N> data_;
+
+
+
+
+
+
460 template <
typename T, std::
size_t N>
+
+
+
+
464 CircularArrayFeatureFlags::kRolloverOnWrite | CircularArrayFeatureFlags::kExtrapolateOnRead |
+
465 CircularArrayFeatureFlags::kLayoutReversal>;
+
+
+
472 template <
typename T, std::
size_t N, CircularArrayFeatureFlags F>
+
+
474 if constexpr (F & CircularArrayFeatureFlags::kLayoutReversal) {
+
+
+
+
+
+
+
+
+
486 template <std::
size_t I,
class T, std::
size_t N, CircularArrayFeatureFlags F>
+
+
+
+
+
+
495 template <std::
size_t I,
class T, std::
size_t N, CircularArrayFeatureFlags F>
+
+
+
+
+
+
504 template <std::
size_t I,
class T, std::
size_t N, CircularArrayFeatureFlags F>
+
+
+
+
+
+
513 template <std::
size_t I,
class T, std::
size_t N, CircularArrayFeatureFlags F>
+
+
+
+
+
+
522 template <
typename T, std::
size_t N, CircularArrayFeatureFlags F, CircularArrayFeatureFlags G>
+
+
+
+
+
+
+
+
+
532 template <
typename T, std::
size_t N, beluga::CircularArrayFeatureFlags F>
+
533 struct tuple_size<beluga::CircularArray<T, N, F>> : std::integral_constant<std::size_t, N> {};
+
+
536 template <std::
size_t I,
typename T, std::
size_t N, beluga::CircularArrayFeatureFlags F>
+
537 struct tuple_element<I, beluga::CircularArray<T, N, F>> {
+
+
+
+
+
+
+
CircularArrayFeatureFlags
Feature flags for circular arrays.
Definition: circular_array.hpp:35
+
+
+
+
constexpr bool operator&(CircularArrayFeatureFlags mask, CircularArrayFeatureFlags flag)
Bitwise AND operator overload to check of the presence of a feature flag in a feature mask.
Definition: circular_array.hpp:53
+
constexpr CircularArrayFeatureFlags operator|(CircularArrayFeatureFlags lflag, CircularArrayFeatureFlags rflag)
Bitwise OR operator overload to combine two feature flags in a single mask-like flag.
Definition: circular_array.hpp:46
+
constexpr T & get(CircularArray< T, N, F > &array) noexcept
Gets an lvalue reference to the ith value in a given array.
Definition: circular_array.hpp:487
+
constexpr void swap(CircularArray< T, N, F > &a, CircularArray< T, N, G > &b)
Swaps arrays a and b.
Definition: circular_array.hpp:523
+
CircularArray< T, N, F > & operator<<(CircularArray< T, N, F > &array, T value)
Convenient stream operator overload to push a value to a circular array.
Definition: circular_array.hpp:473
+
An implementation of generic, non-threadsafe circular array.
Definition: circular_array.hpp:76
+
void swap(CircularArray< T, N, G > &other) noexcept(std::is_nothrow_swappable_v< T >)
Swaps array with another.
Definition: circular_array.hpp:393
+
CircularArray(Iterator first, Sentinel last)
Constructs array from a pair of iterators.
Definition: circular_array.hpp:126
+
constexpr const_iterator cend() const noexcept
Returns a constant iterator pointing past the back of the array.
Definition: circular_array.hpp:185
+
value_type & reference
Value reference type of the array.
Definition: circular_array.hpp:85
+
constexpr const_reference at(size_type index) const
Returns a constant reference to the array value at the given index.
Definition: circular_array.hpp:331
+
constexpr reference at(size_type index)
Returns a reference to the array value at the given index.
Definition: circular_array.hpp:320
+
constexpr size_type effective_size() const noexcept
Returns the effective array size.
Definition: circular_array.hpp:436
+
constexpr const_iterator begin() const noexcept
Returns a constant iterator pointing to the front of the array.
Definition: circular_array.hpp:176
+
const value_type * const_pointer
Constant value pointer type of the arra.y.
Definition: circular_array.hpp:91
+
std::enable_if_t< Enabled > pop_back() noexcept
Pops a value from the back of the array.
Definition: circular_array.hpp:254
+
constexpr size_type max_size() const noexcept
Returns the maximum array size.
Definition: circular_array.hpp:427
+
void clear() noexcept
Clears array.
Definition: circular_array.hpp:384
+
constexpr reference back() noexcept
Returns a reference to the value at the back of the array.
Definition: circular_array.hpp:273
+
constexpr const_reverse_iterator rbegin() const noexcept
Returns a constant reverse iterator pointing to the back of the array.
Definition: circular_array.hpp:190
+
std::enable_if_t< Enabled > pop_front() noexcept
Pops a value from the front of the array.
Definition: circular_array.hpp:265
+
value_type * pointer
Value pointer type of the array.
Definition: circular_array.hpp:89
+
constexpr const_reverse_iterator crend() const noexcept
Returns a constant reverse iterator pointing past the front of the array.
Definition: circular_array.hpp:199
+
IndexingIterator< CircularArray< T, N, F > > iterator
Iterator type of the array.
Definition: circular_array.hpp:97
+
std::enable_if_t< Enabled > push_back(value_type value)
Pushes a value to the back of the array.
Definition: circular_array.hpp:209
+
constexpr iterator end() noexcept
Returns an iterator pointing past the back of the array.
Definition: circular_array.hpp:181
+
constexpr const_reverse_iterator crbegin() const noexcept
Returns a constant reverse iterator pointing to the back of the array.
Definition: circular_array.hpp:192
+
constexpr const T * data() const noexcept
Returns a constant pointer to the underlying array data.
Definition: circular_array.hpp:415
+
constexpr bool full() const noexcept
Returns true if the array is full, false otherwise.
Definition: circular_array.hpp:418
+
std::ptrdiff_t difference_type
Size difference type of the array.
Definition: circular_array.hpp:83
+
CircularArray()=default
Default constructor.
+
constexpr bool empty() const noexcept
Returns true if the array is empty, false otherwise.
Definition: circular_array.hpp:421
+
constexpr const_reverse_iterator rend() const noexcept
Returns a constant reverse iterator pointing past the front of the array.
Definition: circular_array.hpp:197
+
constexpr const_reference front() const noexcept
Returns a constant reference to the value at the front of the array.
Definition: circular_array.hpp:308
+
constexpr reference operator[](size_type index) noexcept
Returns a reference to the array value at the given index.
Definition: circular_array.hpp:342
+
constexpr const_reference back() const noexcept
Returns a constant reference to the value at the back of the array.
Definition: circular_array.hpp:284
+
std::reverse_iterator< const_iterator > const_reverse_iterator
Constant reverse iterator type of the array.
Definition: circular_array.hpp:103
+
CircularArray(T(&&data)[M])
Constructs array from an aggregate.
Definition: circular_array.hpp:163
+
constexpr size_type size() const noexcept
Returns the current array size.
Definition: circular_array.hpp:424
+
constexpr reverse_iterator rbegin() noexcept
Returns a reverse iterator pointing to the back of the array.
Definition: circular_array.hpp:188
+
std::size_t size_type
Size type of the array.
Definition: circular_array.hpp:81
+
constexpr T * data() noexcept
Returns a pointer to the underlying array data.
Definition: circular_array.hpp:408
+
void fill(const T &value)
Fills array to its maximum size with a given value.
Definition: circular_array.hpp:372
+
std::enable_if_t< Enabled > push_front(value_type value)
Pushes a value at the front of the array.
Definition: circular_array.hpp:232
+
IndexingIterator< const CircularArray< T, N, F > > const_iterator
Constant iterator type of the array.
Definition: circular_array.hpp:99
+
constexpr reference front() noexcept
Returns a reference to the value at the front of the array.
Definition: circular_array.hpp:296
+
std::reverse_iterator< iterator > reverse_iterator
Reverse iterator type of the array.
Definition: circular_array.hpp:101
+
void allocator_type
Allocator type of the array (required in range-v3 10.0).
Definition: circular_array.hpp:94
+
constexpr iterator begin() noexcept
Returns an iterator pointing to the front of the array.
Definition: circular_array.hpp:174
+
T value_type
Value type of the array.
Definition: circular_array.hpp:79
+
constexpr const_reference operator[](size_type index) const noexcept
Returns a constant reference to the array value at the given index.
Definition: circular_array.hpp:354
+
constexpr const_iterator end() const noexcept
Returns a constant iterator pointing past the back of the array.
Definition: circular_array.hpp:183
+
const value_type & const_reference
Constant value reference type of the array.
Definition: circular_array.hpp:87
+
constexpr reverse_iterator rend() noexcept
Returns a reverse iterator pointing past the front of the array.
Definition: circular_array.hpp:195
+
constexpr const_iterator cbegin() const noexcept
Returns a constant iterator pointing to the front of the array.
Definition: circular_array.hpp:178
+
A random access iterator for any indexable container.
Definition: indexing_iterator.hpp:38
+
Implementation of a random access iterator for indexable containers.
+
T type
! Always T since circular arrays are homogeneous.
Definition: circular_array.hpp:538
+
+
+
+
+
+
