osb/source/core/StarSmallVector.hpp

445 lines
13 KiB
C++
Raw Normal View History

#pragma once
2023-06-20 04:33:09 +00:00
#include "StarAlgorithm.hpp"
namespace Star {
// A vector that is stack allocated up to a maximum size, becoming heap
// allocated when it grows beyond that size. Always takes up stack space of
// MaxStackSize * sizeof(Element).
template <typename Element, size_t MaxStackSize>
class SmallVector {
public:
typedef Element* iterator;
typedef Element const* const_iterator;
typedef std::reverse_iterator<iterator> reverse_iterator;
typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
typedef Element value_type;
typedef Element& reference;
typedef Element const& const_reference;
SmallVector();
SmallVector(SmallVector const& other);
SmallVector(SmallVector&& other);
template <typename OtherElement, size_t OtherMaxStackSize>
SmallVector(SmallVector<OtherElement, OtherMaxStackSize> const& other);
template <class Iterator>
SmallVector(Iterator first, Iterator last);
SmallVector(size_t size, Element const& value = Element());
SmallVector(initializer_list<Element> list);
~SmallVector();
SmallVector& operator=(SmallVector const& other);
SmallVector& operator=(SmallVector&& other);
SmallVector& operator=(std::initializer_list<Element> list);
size_t size() const;
bool empty() const;
void resize(size_t size, Element const& e = Element());
void reserve(size_t capacity);
reference at(size_t i);
const_reference at(size_t i) const;
reference operator[](size_t i);
const_reference operator[](size_t i) const;
const_iterator begin() const;
const_iterator end() const;
iterator begin();
iterator end();
const_reverse_iterator rbegin() const;
const_reverse_iterator rend() const;
reverse_iterator rbegin();
reverse_iterator rend();
// Pointer to internal data, always valid even if empty.
Element const* ptr() const;
Element* ptr();
void push_back(Element e);
void pop_back();
iterator insert(iterator pos, Element e);
template <typename Iterator>
iterator insert(iterator pos, Iterator begin, Iterator end);
iterator insert(iterator pos, initializer_list<Element> list);
template <typename... Args>
void emplace(iterator pos, Args&&... args);
template <typename... Args>
void emplace_back(Args&&... args);
void clear();
iterator erase(iterator pos);
iterator erase(iterator begin, iterator end);
bool operator==(SmallVector const& other) const;
bool operator!=(SmallVector const& other) const;
bool operator<(SmallVector const& other) const;
private:
typename std::aligned_storage<MaxStackSize * sizeof(Element), alignof(Element)>::type m_stackElements;
bool isHeapAllocated() const;
Element* m_begin;
Element* m_end;
Element* m_capacity;
};
template <typename Element, size_t MaxStackSize>
SmallVector<Element, MaxStackSize>::SmallVector() {
m_begin = (Element*)&m_stackElements;
m_end = m_begin;
m_capacity = m_begin + MaxStackSize;
}
template <typename Element, size_t MaxStackSize>
SmallVector<Element, MaxStackSize>::~SmallVector() {
clear();
if (isHeapAllocated()) {
free(m_begin, (m_capacity - m_begin) * sizeof(Element));
}
}
template <typename Element, size_t MaxStackSize>
SmallVector<Element, MaxStackSize>::SmallVector(SmallVector const& other)
: SmallVector() {
insert(begin(), other.begin(), other.end());
}
template <typename Element, size_t MaxStackSize>
SmallVector<Element, MaxStackSize>::SmallVector(SmallVector&& other)
: SmallVector() {
for (auto& e : other)
emplace_back(std::move(e));
2023-06-20 04:33:09 +00:00
}
template <typename Element, size_t MaxStackSize>
template <typename OtherElement, size_t OtherMaxStackSize>
SmallVector<Element, MaxStackSize>::SmallVector(SmallVector<OtherElement, OtherMaxStackSize> const& other)
: SmallVector() {
for (auto const& e : other)
emplace_back(e);
}
template <typename Element, size_t MaxStackSize>
template <class Iterator>
SmallVector<Element, MaxStackSize>::SmallVector(Iterator first, Iterator last)
: SmallVector() {
insert(begin(), first, last);
}
template <typename Element, size_t MaxStackSize>
SmallVector<Element, MaxStackSize>::SmallVector(size_t size, Element const& value)
: SmallVector() {
resize(size, value);
}
template <typename Element, size_t MaxStackSize>
SmallVector<Element, MaxStackSize>::SmallVector(initializer_list<Element> list)
: SmallVector() {
for (auto const& e : list)
emplace_back(e);
}
template <typename Element, size_t MaxStackSize>
auto SmallVector<Element, MaxStackSize>::operator=(SmallVector const& other) -> SmallVector& {
if (this == &other)
return *this;
resize(other.size());
for (size_t i = 0; i < size(); ++i)
operator[](i) = other[i];
return *this;
}
template <typename Element, size_t MaxStackSize>
auto SmallVector<Element, MaxStackSize>::operator=(SmallVector&& other) -> SmallVector& {
resize(other.size());
for (size_t i = 0; i < size(); ++i)
operator[](i) = std::move(other[i]);
2023-06-20 04:33:09 +00:00
return *this;
}
template <typename Element, size_t MaxStackSize>
auto SmallVector<Element, MaxStackSize>::operator=(std::initializer_list<Element> list) -> SmallVector& {
resize(list.size());
for (size_t i = 0; i < size(); ++i)
operator[](i) = std::move(list[i]);
2023-06-20 04:33:09 +00:00
return *this;
}
template <typename Element, size_t MaxStackSize>
size_t SmallVector<Element, MaxStackSize>::size() const {
return m_end - m_begin;
}
template <typename Element, size_t MaxStackSize>
bool SmallVector<Element, MaxStackSize>::empty() const {
return m_begin == m_end;
}
template <typename Element, size_t MaxStackSize>
void SmallVector<Element, MaxStackSize>::resize(size_t size, Element const& e) {
reserve(size);
for (size_t i = this->size(); i > size; --i)
pop_back();
for (size_t i = this->size(); i < size; ++i)
emplace_back(e);
}
template <typename Element, size_t MaxStackSize>
void SmallVector<Element, MaxStackSize>::reserve(size_t newCapacity) {
size_t oldCapacity = m_capacity - m_begin;
if (newCapacity > oldCapacity) {
newCapacity = max(oldCapacity * 2, newCapacity);
auto newMem = (Element*)Star::malloc(newCapacity * sizeof(Element));
if (!newMem)
2023-06-27 10:23:44 +00:00
throw MemoryException::format("Could not set new SmallVector capacity {}\n", newCapacity);
2023-06-20 04:33:09 +00:00
size_t size = m_end - m_begin;
auto oldMem = m_begin;
auto oldHeapAllocated = isHeapAllocated();
// We assume that move constructors can never throw.
for (size_t i = 0; i < size; ++i) {
new (&newMem[i]) Element(std::move(oldMem[i]));
2023-06-20 04:33:09 +00:00
}
m_begin = newMem;
m_end = m_begin + size;
m_capacity = m_begin + newCapacity;
auto freeOldMem = finally([=]() {
if (oldHeapAllocated)
Star::free(oldMem, oldCapacity * sizeof(Element));
});
for (size_t i = 0; i < size; ++i) {
oldMem[i].~Element();
}
}
}
template <typename Element, size_t MaxStackSize>
auto SmallVector<Element, MaxStackSize>::at(size_t i) -> reference {
if (i >= size())
2023-06-27 10:23:44 +00:00
throw OutOfRangeException::format("out of range in SmallVector::at({})", i);
2023-06-20 04:33:09 +00:00
return m_begin[i];
}
template <typename Element, size_t MaxStackSize>
auto SmallVector<Element, MaxStackSize>::at(size_t i) const -> const_reference {
if (i >= size())
2023-06-27 10:23:44 +00:00
throw OutOfRangeException::format("out of range in SmallVector::at({})", i);
2023-06-20 04:33:09 +00:00
return m_begin[i];
}
template <typename Element, size_t MaxStackSize>
auto SmallVector<Element, MaxStackSize>::operator[](size_t i) -> reference {
starAssert(i < size());
return m_begin[i];
}
template <typename Element, size_t MaxStackSize>
auto SmallVector<Element, MaxStackSize>::operator[](size_t i) const -> const_reference {
starAssert(i < size());
return m_begin[i];
}
template <typename Element, size_t MaxStackSize>
auto SmallVector<Element, MaxStackSize>::begin() const -> const_iterator {
return m_begin;
}
template <typename Element, size_t MaxStackSize>
auto SmallVector<Element, MaxStackSize>::end() const -> const_iterator {
return m_end;
}
template <typename Element, size_t MaxStackSize>
auto SmallVector<Element, MaxStackSize>::begin() -> iterator {
return m_begin;
}
template <typename Element, size_t MaxStackSize>
auto SmallVector<Element, MaxStackSize>::end() -> iterator {
return m_end;
}
template <typename Element, size_t MaxStackSize>
auto SmallVector<Element, MaxStackSize>::rbegin() const -> const_reverse_iterator {
return const_reverse_iterator(end());
}
template <typename Element, size_t MaxStackSize>
auto SmallVector<Element, MaxStackSize>::rend() const -> const_reverse_iterator {
return const_reverse_iterator(begin());
}
template <typename Element, size_t MaxStackSize>
auto SmallVector<Element, MaxStackSize>::rbegin() -> reverse_iterator {
return reverse_iterator(end());
}
template <typename Element, size_t MaxStackSize>
auto SmallVector<Element, MaxStackSize>::rend() -> reverse_iterator {
return reverse_iterator(begin());
}
template <typename Element, size_t MaxStackSize>
Element const* SmallVector<Element, MaxStackSize>::ptr() const {
return m_begin;
}
template <typename Element, size_t MaxStackSize>
Element* SmallVector<Element, MaxStackSize>::ptr() {
return m_begin;
}
template <typename Element, size_t MaxStackSize>
void SmallVector<Element, MaxStackSize>::push_back(Element e) {
emplace_back(std::move(e));
2023-06-20 04:33:09 +00:00
}
template <typename Element, size_t MaxStackSize>
void SmallVector<Element, MaxStackSize>::pop_back() {
if (m_begin == m_end)
throw OutOfRangeException("SmallVector::pop_back called on empty SmallVector");
--m_end;
m_end->~Element();
}
template <typename Element, size_t MaxStackSize>
auto SmallVector<Element, MaxStackSize>::insert(iterator pos, Element e) -> iterator {
emplace(pos, std::move(e));
2023-06-20 04:33:09 +00:00
return pos;
}
template <typename Element, size_t MaxStackSize>
template <typename Iterator>
auto SmallVector<Element, MaxStackSize>::insert(iterator pos, Iterator begin, Iterator end) -> iterator {
size_t toAdd = std::distance(begin, end);
size_t startIndex = pos - m_begin;
size_t endIndex = startIndex + toAdd;
size_t toShift = size() - startIndex;
resize(size() + toAdd);
for (size_t i = toShift; i != 0; --i)
operator[](endIndex + i - 1) = std::move(operator[](startIndex + i - 1));
2023-06-20 04:33:09 +00:00
for (size_t i = 0; i != toAdd; ++i)
operator[](startIndex + i) = *begin++;
return pos;
}
template <typename Element, size_t MaxStackSize>
auto SmallVector<Element, MaxStackSize>::insert(iterator pos, initializer_list<Element> list) -> iterator {
return insert(pos, list.begin(), list.end());
}
template <typename Element, size_t MaxStackSize>
template <typename... Args>
void SmallVector<Element, MaxStackSize>::emplace(iterator pos, Args&&... args) {
size_t index = pos - m_begin;
emplace_back(Element());
for (size_t i = size() - 1; i != index; --i)
operator[](i) = std::move(operator[](i - 1));
operator[](index) = Element(std::forward<Args>(args)...);
2023-06-20 04:33:09 +00:00
}
template <typename Element, size_t MaxStackSize>
template <typename... Args>
void SmallVector<Element, MaxStackSize>::emplace_back(Args&&... args) {
if (m_end == m_capacity)
reserve(size() + 1);
new (m_end) Element(std::forward<Args>(args)...);
2023-06-20 04:33:09 +00:00
++m_end;
}
template <typename Element, size_t MaxStackSize>
void SmallVector<Element, MaxStackSize>::clear() {
while (m_begin != m_end)
pop_back();
}
template <typename Element, size_t MaxStackSize>
auto SmallVector<Element, MaxStackSize>::erase(iterator pos) -> iterator {
size_t index = pos - ptr();
for (size_t i = index; i < size() - 1; ++i)
operator[](i) = std::move(operator[](i + 1));
2023-06-20 04:33:09 +00:00
pop_back();
return pos;
}
template <typename Element, size_t MaxStackSize>
auto SmallVector<Element, MaxStackSize>::erase(iterator begin, iterator end) -> iterator {
size_t startIndex = begin - ptr();
size_t endIndex = end - ptr();
size_t toRemove = endIndex - startIndex;
for (size_t i = endIndex; i < size(); ++i)
operator[](startIndex + (i - endIndex)) = std::move(operator[](i));
2023-06-20 04:33:09 +00:00
resize(size() - toRemove);
return begin;
}
template <typename Element, size_t MaxStackSize>
bool SmallVector<Element, MaxStackSize>::operator==(SmallVector const& other) const {
if (this == &other)
return true;
if (size() != other.size())
return false;
for (size_t i = 0; i < size(); ++i) {
if (operator[](i) != other[i])
return false;
}
return true;
}
template <typename Element, size_t MaxStackSize>
bool SmallVector<Element, MaxStackSize>::operator!=(SmallVector const& other) const {
return !operator==(other);
}
template <typename Element, size_t MaxStackSize>
bool SmallVector<Element, MaxStackSize>::operator<(SmallVector const& other) const {
for (size_t i = 0; i < size(); ++i) {
if (i >= other.size())
return false;
Element const& a = operator[](i);
Element const& b = other[i];
if (a < b)
return true;
else if (b < a)
return false;
}
return size() < other.size();
}
template <typename Element, size_t MaxStackSize>
bool SmallVector<Element, MaxStackSize>::isHeapAllocated() const {
return m_begin != (Element*)&m_stackElements;
}
}