523 lines
14 KiB
C++
523 lines
14 KiB
C++
/*
|
|
* This Source Code Form is subject to the terms of the Mozilla Public
|
|
* License, v. 2.0. If a copy of the MPL was not distributed with this
|
|
* file, You can obtain one at https://mozilla.org/MPL/2.0/.
|
|
*/
|
|
|
|
#pragma once
|
|
|
|
#include "Base/Utils.hpp"
|
|
#include <algorithm>
|
|
#include <cstddef>
|
|
#include <stdexcept>
|
|
#include <optional>
|
|
|
|
namespace OpenVulkano
|
|
{
|
|
constexpr size_t RING_BUFFER_DYNAMIC = std::numeric_limits<size_t>::max();
|
|
|
|
namespace internal_detail
|
|
{
|
|
/**
|
|
* \internal
|
|
* This class is not intended for public use. Use RingBuffer<T> instead.
|
|
*/
|
|
template<typename T, class IMPL>
|
|
class NPCRingBufferBase
|
|
{
|
|
protected:
|
|
size_t count = 0, head = 0;
|
|
|
|
~NPCRingBufferBase() { assert(count == 0); }
|
|
|
|
[[nodiscard]] size_t HeadId() const { return head; }
|
|
private:
|
|
[[nodiscard]] IMPL& Impl() { return *static_cast<IMPL*>(this); }
|
|
[[nodiscard]] const IMPL& Impl() const { return *static_cast<const IMPL*>(this); }
|
|
|
|
//region Iterators
|
|
private:
|
|
template<bool IsConst>
|
|
class ForwardIteratorBase
|
|
{
|
|
using BufferType = std::conditional_t<IsConst, const NPCRingBufferBase, NPCRingBufferBase>;
|
|
using ValueType = std::conditional_t<IsConst, const T, T>;
|
|
|
|
BufferType* buffer;
|
|
size_t index;
|
|
int64_t remainder;
|
|
|
|
public:
|
|
using iterator_category = std::bidirectional_iterator_tag;
|
|
using value_type = T;
|
|
using difference_type = std::ptrdiff_t;
|
|
using pointer = ValueType*;
|
|
using reference = ValueType&;
|
|
|
|
ForwardIteratorBase(BufferType* buf, size_t startIdx, int64_t remainder)
|
|
: buffer(buf), index(startIdx), remainder(remainder) {}
|
|
|
|
reference operator*() const { return buffer->data()[index]; }
|
|
pointer operator->() const { return &buffer->data()[index]; }
|
|
|
|
ForwardIteratorBase& operator++()
|
|
{
|
|
if (remainder > 1)
|
|
{
|
|
if (index == buffer->capacity() - 1)
|
|
index = 0;
|
|
else
|
|
++index;
|
|
}
|
|
remainder--;
|
|
return *this;
|
|
}
|
|
|
|
ForwardIteratorBase operator++(int)
|
|
{
|
|
ForwardIteratorBase tmp = *this;
|
|
++(*this);
|
|
return tmp;
|
|
}
|
|
|
|
ForwardIteratorBase& operator--()
|
|
{
|
|
if (remainder == 0) { remainder++; return *this; }
|
|
if (index == 0)
|
|
index = buffer->capacity() - 1;
|
|
else
|
|
--index;
|
|
remainder++;
|
|
return *this;
|
|
}
|
|
|
|
ForwardIteratorBase operator--(int)
|
|
{
|
|
ForwardIteratorBase tmp = *this;
|
|
--(*this);
|
|
return tmp;
|
|
}
|
|
|
|
friend bool operator==(const ForwardIteratorBase& a, const ForwardIteratorBase& b)
|
|
{
|
|
return a.buffer == b.buffer && a.index == b.index && a.remainder == b.remainder;
|
|
}
|
|
|
|
friend bool operator!=(const ForwardIteratorBase& a, const ForwardIteratorBase& b)
|
|
{
|
|
return !(a == b);
|
|
}
|
|
};
|
|
|
|
template<bool IsConst>
|
|
class ReverseIteratorBase
|
|
{
|
|
using BufferType = std::conditional_t<IsConst, const NPCRingBufferBase, NPCRingBufferBase>;
|
|
using ValueType = std::conditional_t<IsConst, const T, T>;
|
|
|
|
BufferType* buffer;
|
|
size_t index;
|
|
int64_t remainder;
|
|
|
|
public:
|
|
using iterator_category = std::bidirectional_iterator_tag;
|
|
using value_type = T;
|
|
using difference_type = std::ptrdiff_t;
|
|
using pointer = ValueType*;
|
|
using reference = ValueType&;
|
|
|
|
ReverseIteratorBase(BufferType* buf, size_t startIdx, int64_t remainder)
|
|
: buffer(buf), index(startIdx), remainder(remainder) {}
|
|
|
|
reference operator*() const { return buffer->data()[index]; }
|
|
pointer operator->() const { return &buffer->data()[index]; }
|
|
|
|
ReverseIteratorBase& operator++()
|
|
{
|
|
if (remainder > 1)
|
|
{
|
|
if (index == 0)
|
|
index = buffer->capacity() - 1;
|
|
else
|
|
--index;
|
|
}
|
|
remainder--;
|
|
return *this;
|
|
}
|
|
|
|
ReverseIteratorBase operator++(int)
|
|
{
|
|
ReverseIteratorBase tmp = *this;
|
|
++(*this);
|
|
return tmp;
|
|
}
|
|
|
|
ReverseIteratorBase& operator--()
|
|
{
|
|
if (remainder == 0) { remainder++; return *this; }
|
|
if (index == buffer->capacity() - 1)
|
|
index = 0;
|
|
else
|
|
++index;
|
|
remainder++;
|
|
return *this;
|
|
}
|
|
|
|
ReverseIteratorBase operator--(int)
|
|
{
|
|
ReverseIteratorBase tmp = *this;
|
|
--(*this);
|
|
return tmp;
|
|
}
|
|
|
|
friend bool operator==(const ReverseIteratorBase& a, const ReverseIteratorBase& b)
|
|
{
|
|
return a.buffer == b.buffer && a.index == b.index && a.remainder == b.remainder;
|
|
}
|
|
|
|
friend bool operator!=(const ReverseIteratorBase& a, const ReverseIteratorBase& b)
|
|
{
|
|
return !(a == b);
|
|
}
|
|
};
|
|
|
|
public:
|
|
using iterator = ForwardIteratorBase<false>;
|
|
using const_iterator = ForwardIteratorBase<true>;
|
|
|
|
iterator begin() { return iterator(this, Impl().TailId(), count); }
|
|
iterator end() { return iterator(this, HeadId(), 0); }
|
|
|
|
const_iterator begin() const { return cbegin(); }
|
|
const_iterator end() const { return cend(); }
|
|
|
|
const_iterator cbegin() const { return const_iterator(this, Impl().TailId(), count); }
|
|
const_iterator cend() const { return const_iterator(this, HeadId(), 0); }
|
|
|
|
using reverse_iterator = ReverseIteratorBase<false>;
|
|
using const_reverse_iterator = ReverseIteratorBase<true>;
|
|
|
|
reverse_iterator rbegin() { return reverse_iterator(this, HeadId(), count); }
|
|
reverse_iterator rend() { return reverse_iterator(this, Impl().TailId(), 0); }
|
|
|
|
const_reverse_iterator rbegin() const { return crbegin(); }
|
|
const_reverse_iterator rend() const { return crend(); }
|
|
|
|
const_reverse_iterator crbegin() const { return const_reverse_iterator(this, HeadId(), count); }
|
|
const_reverse_iterator crend() const { return const_reverse_iterator(this, Impl().TailId(), 0); }
|
|
//endregion
|
|
|
|
public:
|
|
[[nodiscard]] size_t capacity() const { return Impl().Capacity(); }
|
|
[[nodiscard]] T* data() { return Impl().Data(); }
|
|
[[nodiscard]] const T* data() const { return Impl().Data(); }
|
|
|
|
public:
|
|
[[nodiscard]] size_t Count() const { return count; }
|
|
[[nodiscard]] size_t Size() const { return count; }
|
|
[[nodiscard]] bool IsEmpty() const { return count == 0; }
|
|
[[nodiscard]] bool HasFree() const { return Count() != capacity(); }
|
|
|
|
T PopFront()
|
|
{
|
|
if (IsEmpty()) throw std::underflow_error("RingBuffer is empty");
|
|
|
|
T value = std::move(data()[head]);
|
|
data()[head].~T();
|
|
if (head == 0) head = capacity() - 1;
|
|
else head--;
|
|
count--;
|
|
return value;
|
|
}
|
|
|
|
T PopBack()
|
|
{
|
|
if (IsEmpty()) throw std::underflow_error("RingBuffer is empty");
|
|
size_t tail = Impl().TailId();
|
|
T value = std::move(data()[tail]);
|
|
data()[tail].~T();
|
|
count--;
|
|
return value;
|
|
}
|
|
|
|
void Clear()
|
|
{
|
|
while(count)
|
|
{
|
|
data()[head].~T();
|
|
if (head == 0) head = capacity() - 1;
|
|
else head--;
|
|
count--;
|
|
}
|
|
}
|
|
|
|
[[nodiscard]] T& Back() { return data()[Impl().TailId()]; }
|
|
[[nodiscard]] const T& Back() const { return data()[Impl().TailId()]; }
|
|
|
|
[[nodiscard]] T& Front() { return data()[head]; }
|
|
[[nodiscard]] const T& Front() const { return data()[head]; }
|
|
|
|
//region Insertion
|
|
void PushNoOverwrite(const T& value) { if (!HasFree()) throw std::overflow_error("RingBuffer is full"); Push(value); }
|
|
void PushNoOverwrite(T&& value) { if (!HasFree()) throw std::overflow_error("RingBuffer is full"); Push(std::move(value)); }
|
|
template<typename... Args>
|
|
void EmplaceNoOverwrite(Args&&... args)
|
|
{
|
|
if (!HasFree()) throw std::overflow_error("RingBuffer is full");
|
|
Emplace(std::forward<Args...>(args...));
|
|
}
|
|
|
|
void Push(const T& value)
|
|
{
|
|
Impl().IncrementHead();
|
|
if (HasFree()) count++;
|
|
else data()[head].~T();
|
|
new (&data()[head]) T(value);
|
|
}
|
|
|
|
void Push(T&& value)
|
|
{
|
|
Impl().IncrementHead();
|
|
if (HasFree()) count++;
|
|
else data()[head].~T();
|
|
new (&data()[head]) T(std::move(value));
|
|
}
|
|
|
|
template<typename... Args>
|
|
void Emplace(Args&&... args)
|
|
{
|
|
Impl().IncrementHead();
|
|
if (HasFree()) count++;
|
|
else data()[head].~T();
|
|
new (&data()[head]) T(std::forward<Args>(args)...);
|
|
}
|
|
|
|
[[nodiscard]] std::optional<T> PushFront(const T& value)
|
|
{
|
|
if (HasFree())
|
|
{
|
|
count++;
|
|
Impl().IncrementHead();
|
|
new (&data()[head]) T(value);
|
|
return std::nullopt;
|
|
}
|
|
Impl().IncrementHead();
|
|
std::optional<T> oldData(std::move(Front()));
|
|
data()[head].~T();
|
|
new (&data()[head]) T(value);
|
|
return oldData;
|
|
}
|
|
|
|
[[nodiscard]] std::optional<T> PushFront(T&& value)
|
|
{
|
|
if (HasFree())
|
|
{
|
|
count++;
|
|
Impl().IncrementHead();
|
|
new (&data()[head]) T(std::move(value));
|
|
return std::nullopt;
|
|
}
|
|
Impl().IncrementHead();
|
|
std::optional<T> oldData(std::move(Front()));
|
|
data()[head].~T();
|
|
new (&data()[head]) T(std::move(value));
|
|
return oldData;
|
|
}
|
|
|
|
template<typename... Args>
|
|
[[nodiscard]] std::optional<T> EmplaceFront(Args&&... args)
|
|
{
|
|
if (HasFree())
|
|
{
|
|
count++;
|
|
Impl().IncrementHead();
|
|
new (&data()[head]) T(std::forward<Args>(args)...);
|
|
return std::nullopt;
|
|
}
|
|
Impl().IncrementHead();
|
|
std::optional<T> oldData(std::move(Front()));
|
|
data()[head].~T();
|
|
new (&data()[head]) T(std::forward<Args>(args)...);
|
|
return oldData;
|
|
}
|
|
|
|
std::optional<T> PushBack(const T& value)
|
|
{
|
|
if (HasFree())
|
|
{
|
|
count++;
|
|
new (&data()[Impl().TailId()]) T(value);
|
|
return std::nullopt;
|
|
}
|
|
size_t tail = Impl().TailId();
|
|
std::optional<T> oldData(std::move(data()[tail]));
|
|
data()[tail].~T();
|
|
new (&data()[tail]) T(value);
|
|
return oldData;
|
|
}
|
|
|
|
std::optional<T> PushBack(T&& value)
|
|
{
|
|
if (HasFree())
|
|
{
|
|
count++;
|
|
new (&data()[Impl().TailId()]) T(std::move(value));
|
|
return std::nullopt;
|
|
}
|
|
size_t tail = Impl().TailId();
|
|
std::optional<T> oldData(std::move(data()[tail]));
|
|
data()[tail].~T();
|
|
new (&data()[tail]) T(std::move(value));
|
|
return oldData;
|
|
}
|
|
|
|
template<typename... Args>
|
|
std::optional<T> EmplaceBack(Args&&... args)
|
|
{
|
|
if (HasFree())
|
|
{
|
|
count++;
|
|
new (&data()[Impl().TailId()]) T(std::forward<Args>(args)...);
|
|
return std::nullopt;
|
|
}
|
|
size_t tail = Impl().TailId();
|
|
std::optional<T> oldData(std::move(data()[tail]));
|
|
data()[tail].~T();
|
|
new (&data()[tail]) T(std::forward<Args>(args)...);
|
|
return oldData;
|
|
}
|
|
|
|
T PushAndOverwrite(const T& value)
|
|
{
|
|
if (HasFree()) [[unlikely]] throw std::runtime_error("Can't overwrite data because there are still empty slots.");
|
|
Impl().IncrementHead();
|
|
T oldData(std::move(Front()));
|
|
data()[head].~T();
|
|
new (&data()[head]) T(value);
|
|
return oldData;
|
|
}
|
|
|
|
T PushAndOverwrite(T&& value)
|
|
{
|
|
if (HasFree()) [[unlikely]] throw std::runtime_error("Can't overwrite data because there are still empty slots.");
|
|
Impl().IncrementHead();
|
|
T oldData(std::move(Front()));
|
|
data()[head].~T();
|
|
new (&data()[head]) T(std::move(value));
|
|
return oldData;
|
|
}
|
|
|
|
template<typename... Args>
|
|
T PushAndOverwrite(Args&&... args)
|
|
{
|
|
if (HasFree()) [[unlikely]] throw std::runtime_error("Can't overwrite data because there are still empty slots.");
|
|
Impl().IncrementHead();
|
|
T oldData(std::move(Front()));
|
|
data()[head].~T();
|
|
new (&data()[head]) T(std::forward<Args>(args)...);
|
|
return oldData;
|
|
}
|
|
//endregion
|
|
|
|
[[nodiscard]] T& at(size_t idx) { if (idx >= Size()) throw std::range_error("Out of bounds"); return (*this)[idx]; }
|
|
[[nodiscard]] const T& at(size_t idx) const { if (idx >= Size()) throw std::range_error("Out of bounds"); return (*this)[idx]; }
|
|
|
|
[[nodiscard]] T& operator[](size_t idx)
|
|
{
|
|
return data()[Impl().Index(idx)];
|
|
}
|
|
|
|
[[nodiscard]] const T& operator[](size_t idx) const
|
|
{
|
|
return data()[Impl().Index(idx)];
|
|
}
|
|
|
|
void Fill(const T& value)
|
|
{
|
|
while(HasFree()) { Push(value); }
|
|
}
|
|
};
|
|
}
|
|
|
|
template<typename T, size_t SIZE = RING_BUFFER_DYNAMIC>
|
|
class RingBuffer;
|
|
|
|
template<typename T>
|
|
class RingBuffer<T, RING_BUFFER_DYNAMIC> final : public internal_detail::NPCRingBufferBase<T, RingBuffer<T, RING_BUFFER_DYNAMIC>>
|
|
{
|
|
typedef internal_detail::NPCRingBufferBase<T, RingBuffer<T, RING_BUFFER_DYNAMIC>> Parent;
|
|
friend Parent;
|
|
|
|
struct RawFreeDeleter { void operator()(void* ptr) const { ::operator delete(ptr); } };
|
|
|
|
std::unique_ptr<T, RawFreeDeleter> m_data;
|
|
size_t m_capacity;
|
|
|
|
[[nodiscard]] size_t TailId() const
|
|
{
|
|
if (Parent::IsEmpty()) [[unlikely]] return Parent::head;
|
|
return (Parent::HeadId() + 1 + Capacity() - Parent::Count()) % Capacity();
|
|
}
|
|
|
|
size_t IncrementHead()
|
|
{
|
|
if (Parent::IsEmpty()) [[unlikely]] return Parent::head;
|
|
return (Parent::head = (Parent::HeadId() + 1) % Capacity());
|
|
}
|
|
|
|
[[nodiscard]] size_t Index(size_t i) const { return (TailId() + i) % Capacity(); }
|
|
public:
|
|
RingBuffer(const size_t size = 10): m_data(static_cast<T*>(::operator new(sizeof(T) * size))), m_capacity(size) {}
|
|
|
|
~RingBuffer() { Parent::Clear(); }
|
|
|
|
[[nodiscard]] size_t Capacity() const { return m_capacity; }
|
|
[[nodiscard]] T* Data() { return m_data.get(); }
|
|
[[nodiscard]] const T* Data() const { return m_data.get(); }
|
|
};
|
|
|
|
template<typename T, size_t SIZE>
|
|
class RingBuffer final : public internal_detail::NPCRingBufferBase<T, RingBuffer<T, SIZE>>
|
|
{
|
|
typedef internal_detail::NPCRingBufferBase<T, RingBuffer<T, SIZE>> Parent;
|
|
friend Parent;
|
|
constexpr static bool POW2 = (Utils::IsPow2(SIZE) && SIZE > 0);
|
|
constexpr static size_t MASK = SIZE - 1;
|
|
|
|
using StorageType = typename std::aligned_storage<sizeof(T), alignof(T)>::type;
|
|
StorageType m_data[SIZE]; // Uninitialized raw storage
|
|
|
|
[[nodiscard]] size_t Index(size_t i) const
|
|
{
|
|
if constexpr (POW2)
|
|
return (Parent::HeadId() - (Parent::Count() - 1) + i) & MASK;
|
|
else
|
|
return (TailId() + i) % Capacity();
|
|
}
|
|
|
|
[[nodiscard]] size_t TailId() const
|
|
{
|
|
if (Parent::IsEmpty()) [[unlikely]] return Parent::head;
|
|
if constexpr (POW2)
|
|
return (Parent::HeadId() - (Parent::Count() - 1)) & MASK;
|
|
else
|
|
return (Parent::HeadId() + 1 + Capacity() - Parent::Count()) % Capacity();
|
|
}
|
|
|
|
size_t IncrementHead()
|
|
{
|
|
if (Parent::IsEmpty()) [[unlikely]] return Parent::head;
|
|
if constexpr (POW2)
|
|
return (Parent::head = (Parent::HeadId() + 1) & MASK);
|
|
else
|
|
return (Parent::head = (Parent::HeadId() + 1) % Capacity());
|
|
}
|
|
|
|
public:
|
|
~RingBuffer() { Parent::Clear(); }
|
|
|
|
[[nodiscard]] size_t Capacity() const { return SIZE; }
|
|
[[nodiscard]] T* Data() { return reinterpret_cast<T*>(m_data); }
|
|
[[nodiscard]] const T* Data() const { return reinterpret_cast<const T*>(m_data); }
|
|
};
|
|
} |