From 743748734097be36daa6363c8cd76a91f44537eb Mon Sep 17 00:00:00 2001 From: Gary Talent Date: Sun, 18 Jun 2023 01:39:35 -0500 Subject: [PATCH] [ox/std] Make many Vector functions conditionally noexcept --- deps/ox/src/ox/std/vector.hpp | 86 +++++++++++++++++++---------------- 1 file changed, 46 insertions(+), 40 deletions(-) diff --git a/deps/ox/src/ox/std/vector.hpp b/deps/ox/src/ox/std/vector.hpp index 8e029e41..325e8780 100644 --- a/deps/ox/src/ox/std/vector.hpp +++ b/deps/ox/src/ox/std/vector.hpp @@ -235,7 +235,7 @@ class Vector: detail::VectorAllocator { }; private: - static constexpr auto initialSize = SmallVectorSize > 0 ? SmallVectorSize : 50; + static constexpr auto initialCap = SmallVectorSize > 0 ? SmallVectorSize : 50; std::size_t m_size = 0; std::size_t m_cap = 0; T *m_items = nullptr; @@ -247,7 +247,7 @@ class Vector: detail::VectorAllocator { constexpr Vector(std::initializer_list list) noexcept; - constexpr Vector(const Vector &other); + constexpr Vector(const Vector &other) noexcept(ox::is_integral_v); constexpr Vector(Vector &&other) noexcept; @@ -311,9 +311,9 @@ class Vector: detail::VectorAllocator { return iterator(m_items, MaxValue, m_size); } - constexpr bool operator==(const Vector &other) const; + constexpr bool operator==(const Vector &other) const noexcept(ox::is_integral_v); - constexpr Vector &operator=(const Vector &other); + constexpr Vector &operator=(const Vector &other) noexcept(ox::is_integral_v); constexpr Vector &operator=(Vector &&other) noexcept; @@ -339,9 +339,9 @@ class Vector: detail::VectorAllocator { [[nodiscard]] constexpr bool empty() const noexcept; - constexpr void clear(); + constexpr void clear() noexcept(ox::is_integral_v); - constexpr void resize(std::size_t size); + constexpr void resize(std::size_t size) noexcept(ox::is_integral_v); [[nodiscard]] constexpr T *data() noexcept { @@ -354,35 +354,36 @@ class Vector: detail::VectorAllocator { } [[nodiscard]] - constexpr bool contains(const T&) const; + constexpr bool contains(const T&) const noexcept(ox::is_integral_v); - constexpr iterator<> insert(std::size_t pos, std::size_t cnt, const T &val); + constexpr iterator<> insert( + std::size_t pos, std::size_t cnt, const T &val) noexcept(ox::is_integral_v); - constexpr iterator<> insert(std::size_t pos, const T &val); + constexpr iterator<> insert(std::size_t pos, const T &val) noexcept(ox::is_integral_v); template - constexpr iterator<> emplace(std::size_t pos, Args&&... args); + constexpr iterator<> emplace(std::size_t pos, Args&&... args) noexcept(ox::is_integral_v); template - constexpr T &emplace_back(Args&&... args); + constexpr T &emplace_back(Args&&... args) noexcept(ox::is_integral_v); - constexpr void push_back(const T &item); + constexpr void push_back(const T &item) noexcept(ox::is_integral_v); - constexpr void pop_back(); + constexpr void pop_back() noexcept(ox::is_integral_v); /** * Removes an item from the Vector. * @param pos iterator at the point to remove * @return Error if index is out of bounds */ - constexpr Result> erase(const iterator<> &pos); + constexpr Result> erase(const iterator<> &pos) noexcept(ox::is_integral_v); /** * Removes an item from the Vector. * @param pos position of item to remove * @return Error if index is out of bounds */ - constexpr Result> erase(std::size_t pos); + constexpr Result> erase(std::size_t pos) noexcept(ox::is_integral_v); /** * Moves the last item in the Vector to position pos and decrements the @@ -390,12 +391,13 @@ class Vector: detail::VectorAllocator { * @param pos position of item to remove * @return Error if index is out of bounds */ - constexpr Error unordered_erase(std::size_t pos); + constexpr Error unordered_erase(std::size_t pos) noexcept(ox::is_integral_v); - constexpr void reserve(std::size_t cap); + constexpr void reserve(std::size_t cap) noexcept(ox::is_integral_v); private: - constexpr void reserveInsert(std::size_t cap, std::size_t pos, std::size_t offset = 1); + constexpr void reserveInsert( + std::size_t cap, std::size_t pos, std::size_t offset = 1) noexcept(ox::is_integral_v); }; @@ -427,7 +429,7 @@ constexpr Vector::Vector(std::initializer_list } template -constexpr Vector::Vector(const Vector &other) { +constexpr Vector::Vector(const Vector &other) noexcept(ox::is_integral_v) { m_size = other.m_size; m_cap = other.m_cap; this->allocate(&m_items, other.m_cap); @@ -455,7 +457,8 @@ constexpr Vector::~Vector() { } template -constexpr bool Vector::operator==(const Vector &other) const { +constexpr bool Vector::operator==( + const Vector &other) const noexcept(ox::is_integral_v) { if (m_size != other.m_size) { return false; } @@ -469,7 +472,7 @@ constexpr bool Vector::operator==(const Vector &o template constexpr Vector &Vector::operator=( - const Vector &other) { + const Vector &other) noexcept(ox::is_integral_v) { if (this != &other) { clear(); this->deallocate(m_items, m_cap); @@ -554,7 +557,7 @@ constexpr bool Vector::empty() const noexcept { } template -constexpr void Vector::clear() { +constexpr void Vector::clear() noexcept(ox::is_integral_v) { if constexpr(is_class()) { for (std::size_t i = 0; i < m_size; ++i) { m_items[i].~T(); @@ -564,7 +567,7 @@ constexpr void Vector::clear() { } template -constexpr void Vector::resize(std::size_t size) { +constexpr void Vector::resize(std::size_t size) noexcept(ox::is_integral_v) { if (m_cap < size) { reserve(size * 2); } @@ -581,7 +584,7 @@ constexpr void Vector::resize(std::size_t size) { } template -constexpr bool Vector::contains(const T &v) const { +constexpr bool Vector::contains(const T &v) const noexcept(ox::is_integral_v) { for (std::size_t i = 0; i < m_size; i++) { if (m_items[i] == v) { return true; @@ -592,9 +595,10 @@ constexpr bool Vector::contains(const T &v) const template constexpr typename Vector::template iterator<> -Vector::insert(std::size_t pos, std::size_t cnt, const T &val) { +Vector::insert( + std::size_t pos, std::size_t cnt, const T &val) noexcept(ox::is_integral_v) { if (m_size + cnt > m_cap) { - reserveInsert(m_cap ? m_size + cnt : initialSize, pos, cnt); + reserveInsert(m_cap ? m_size + cnt : initialCap, pos, cnt); if (pos < m_size) { m_items[pos] = val; } else { @@ -620,9 +624,9 @@ Vector::insert(std::size_t pos, std::size_t cnt, template constexpr typename Vector::template iterator<> -Vector::insert(std::size_t pos, const T &val) { +Vector::insert(std::size_t pos, const T &val) noexcept(ox::is_integral_v) { if (m_size == m_cap) { - reserveInsert(m_cap ? m_cap * 2 : initialSize, pos); + reserveInsert(m_cap ? m_cap * 2 : initialCap, pos); if (pos < m_size) { m_items[pos] = val; } else { @@ -645,9 +649,9 @@ Vector::insert(std::size_t pos, const T &val) { template template constexpr typename Vector::template iterator<> -Vector::emplace(std::size_t pos, Args&&... args) { +Vector::emplace(std::size_t pos, Args&&... args) noexcept(ox::is_integral_v) { if (m_size == m_cap) { - reserveInsert(m_cap ? m_cap * 2 : initialSize); + reserveInsert(m_cap ? m_cap * 2 : initialCap); if (pos < m_size) { m_items[pos].~T(); } @@ -667,9 +671,10 @@ Vector::emplace(std::size_t pos, Args&&... args) template template -constexpr T &Vector::emplace_back(Args&&... args) { +constexpr T &Vector::emplace_back(Args&&... args) +noexcept(ox::is_integral_v) { if (m_size == m_cap) { - reserve(m_cap ? m_cap * 2 : initialSize); + reserve(m_cap ? m_cap * 2 : initialCap); } auto out = std::construct_at(&m_items[m_size], ox::forward(args)...); ++m_size; @@ -677,29 +682,29 @@ constexpr T &Vector::emplace_back(Args&&... args) } template -constexpr void Vector::push_back(const T &item) { +constexpr void Vector::push_back(const T &item) noexcept(ox::is_integral_v) { if (m_size == m_cap) { - reserve(m_cap ? m_cap * 2 : initialSize); + reserve(m_cap ? m_cap * 2 : initialCap); } std::construct_at(&m_items[m_size], item); ++m_size; } template -constexpr void Vector::pop_back() { +constexpr void Vector::pop_back() noexcept(ox::is_integral_v) { --m_size; m_items[m_size].~T(); } template constexpr Result::template iterator> -Vector::erase(const iterator<> &pos) { +Vector::erase(const iterator<> &pos) noexcept(ox::is_integral_v) { return erase(pos.offset()); } template constexpr Result::template iterator> -Vector::erase(std::size_t pos) { +Vector::erase(std::size_t pos) noexcept(ox::is_integral_v) { if (pos >= m_size) { return OxError(1, "Vector::erase failed: pos is greater than Vector size"); } @@ -712,7 +717,8 @@ Vector::erase(std::size_t pos) { } template -constexpr Error Vector::unordered_erase(std::size_t pos) { +constexpr Error Vector::unordered_erase(std::size_t pos) + noexcept(ox::is_integral_v) { if (pos >= m_size) { return OxError(1); } @@ -723,7 +729,7 @@ constexpr Error Vector::unordered_erase(std::size } template -constexpr void Vector::reserve(std::size_t cap) { +constexpr void Vector::reserve(std::size_t cap) noexcept(ox::is_integral_v) { if (cap <= m_cap) { return; } @@ -745,7 +751,7 @@ template constexpr void Vector::reserveInsert( std::size_t cap, std::size_t pos, - std::size_t offset) { + std::size_t offset) noexcept(ox::is_integral_v) { if (cap <= m_cap) { return; }