From 9d74c5b464e7d97c09720bc9993bd6b3033a4fd4 Mon Sep 17 00:00:00 2001 From: Gary Talent Date: Sun, 18 Apr 2021 14:33:06 -0500 Subject: [PATCH] [ox/fs/ptrarith] Make everything in ptrarith noexcept --- deps/ox/src/ox/fs/ptrarith/nodebuffer.hpp | 116 ++++++++++++---------- deps/ox/src/ox/fs/ptrarith/ptr.hpp | 93 ++++++++--------- 2 files changed, 110 insertions(+), 99 deletions(-) diff --git a/deps/ox/src/ox/fs/ptrarith/nodebuffer.hpp b/deps/ox/src/ox/fs/ptrarith/nodebuffer.hpp index 78abaecb..c289910f 100644 --- a/deps/ox/src/ox/fs/ptrarith/nodebuffer.hpp +++ b/deps/ox/src/ox/fs/ptrarith/nodebuffer.hpp @@ -34,45 +34,48 @@ class OX_PACKED NodeBuffer { size_t m_it = 0; public: - Iterator(NodeBuffer *buffer, ItemPtr current) { + Iterator(NodeBuffer *buffer, ItemPtr current) noexcept { m_buffer = buffer; m_current = current; oxTrace("ox::ptrarith::Iterator::start") << current.offset(); } - operator const Item*() const { + operator const Item*() const noexcept { return m_current; } - ItemPtr ptr() { + ItemPtr ptr() noexcept { return m_current; } - Item *get() { + [[nodiscard]] + Item *get() noexcept { return m_current; } - operator ItemPtr() { + operator ItemPtr() noexcept { return m_current; } - operator Item*() { + operator Item*() noexcept { return m_current; } - const Item *operator->() const { + const Item *operator->() const noexcept { return m_current; } - Item *operator->() { + Item *operator->() noexcept { return m_current; } - [[nodiscard]] bool valid() const noexcept { + [[nodiscard]] + bool valid() const noexcept { return m_current.valid(); } - bool hasNext() { + [[nodiscard]] + bool hasNext() noexcept { if (m_current.valid()) { oxTrace("ox::ptrarith::NodeBuffer::Iterator::hasNext::current") << m_current.offset(); auto next = m_buffer->next(m_current); @@ -81,7 +84,7 @@ class OX_PACKED NodeBuffer { return false; } - void next() { + void next() noexcept { oxTrace("ox::ptrarith::NodeBuffer::Iterator::next") << m_it++; if (hasNext()) { m_current = m_buffer->next(m_current); @@ -94,76 +97,83 @@ class OX_PACKED NodeBuffer { Header m_header; public: - NodeBuffer(); + NodeBuffer() noexcept; - NodeBuffer(const NodeBuffer &other, size_t size); + NodeBuffer(const NodeBuffer &other, size_t size) noexcept; - explicit NodeBuffer(size_t size); + explicit NodeBuffer(size_t size) noexcept; - const Iterator iterator() const; + [[nodiscard]] + const Iterator iterator() const noexcept; - Iterator iterator(); + [[nodiscard]] + Iterator iterator() noexcept; - ItemPtr firstItem(); + ItemPtr firstItem() noexcept; - ItemPtr lastItem(); + ItemPtr lastItem() noexcept; /** * @return the data section of the given item */ template - Ptr dataOf(ItemPtr); + Ptr dataOf(ItemPtr) noexcept; - [[nodiscard]] ItemPtr prev(Item *item); + ItemPtr prev(Item *item) noexcept; - [[nodiscard]] ItemPtr next(Item *item); + ItemPtr next(Item *item) noexcept; /** * Like pointer but omits checks that assume the memory at the offset has * already been initialed as an Item. */ - [[nodiscard]] ItemPtr uninitializedPtr(size_t offset); + ItemPtr uninitializedPtr(size_t offset) noexcept; - [[nodiscard]] ItemPtr ptr(size_t offset); + ItemPtr ptr(size_t offset) noexcept; - [[nodiscard]] ItemPtr malloc(size_t size); + ItemPtr malloc(size_t size) noexcept; - Error free(ItemPtr item); + Error free(ItemPtr item) noexcept; - [[nodiscard]] bool valid(size_t maxSize); + [[nodiscard]] + bool valid(size_t maxSize) noexcept; /** * Set size, capacity. */ - Error setSize(size_t size); + Error setSize(size_t size) noexcept; /** * Get size, capacity. * @return capacity */ - size_t size(); + [[nodiscard]] + constexpr size_t size() const noexcept; /** * @return the bytes still available in this NodeBuffer */ - size_t available(); + [[nodiscard]] + size_t available() noexcept; /** * @return the actual number a bytes need to store the given number of * bytes */ - static size_t spaceNeeded(size_t size); + [[nodiscard]] + static size_t spaceNeeded(size_t size) noexcept; template - Error compact(F cb = [](uint64_t, ItemPtr) {}); + Error compact(F cb = [](uint64_t, ItemPtr) {}) noexcept; -private: - uint8_t *data(); + private: + [[nodiscard]] + uint8_t *data() noexcept; }; template -NodeBuffer::NodeBuffer(size_t size) { +NodeBuffer::NodeBuffer(size_t size) noexcept { m_header.size = size; auto data = reinterpret_cast(this) + sizeof(*this); ox_memset(data, 0, size - sizeof(*this)); @@ -171,7 +181,7 @@ NodeBuffer::NodeBuffer(size_t size) { } template -NodeBuffer::NodeBuffer(const NodeBuffer &other, size_t size) { +NodeBuffer::NodeBuffer(const NodeBuffer &other, size_t size) noexcept { oxTrace("ox::ptrarith::NodeBuffer::copy") << "other.m_header.firstItem:" << other.m_header.firstItem; auto data = reinterpret_cast(this) + sizeof(*this); ox_memset(data, 0, size - sizeof(*this)); @@ -179,24 +189,24 @@ NodeBuffer::NodeBuffer(const NodeBuffer &other, size_t size) { } template -const typename NodeBuffer::Iterator NodeBuffer::iterator() const { +const typename NodeBuffer::Iterator NodeBuffer::iterator() const noexcept { return Iterator(this, firstItem()); } template -typename NodeBuffer::Iterator NodeBuffer::iterator() { +typename NodeBuffer::Iterator NodeBuffer::iterator() noexcept { oxTrace("ox::ptrarith::NodeBuffer::iterator::size") << m_header.size; return Iterator(this, firstItem()); } template -typename NodeBuffer::ItemPtr NodeBuffer::firstItem() { +typename NodeBuffer::ItemPtr NodeBuffer::firstItem() noexcept { //oxTrace("ox::ptrarith::NodeBuffer::firstItem") << m_header.firstItem; return ptr(m_header.firstItem); } template -typename NodeBuffer::ItemPtr NodeBuffer::lastItem() { +typename NodeBuffer::ItemPtr NodeBuffer::lastItem() noexcept { auto first = ptr(m_header.firstItem); if (first.valid()) { return prev(first); @@ -206,24 +216,24 @@ typename NodeBuffer::ItemPtr NodeBuffer::lastItem() template template -Ptr NodeBuffer::dataOf(ItemPtr ip) { +Ptr NodeBuffer::dataOf(ItemPtr ip) noexcept { auto out = ip.template subPtr(sizeof(Item)); oxAssert(out.size() == ip.size() - sizeof(Item), "Sub Ptr has invalid size."); return out; } template -typename NodeBuffer::ItemPtr NodeBuffer::prev(Item *item) { +typename NodeBuffer::ItemPtr NodeBuffer::prev(Item *item) noexcept { return ptr(item->prev); } template -typename NodeBuffer::ItemPtr NodeBuffer::next(Item *item) { +typename NodeBuffer::ItemPtr NodeBuffer::next(Item *item) noexcept { return ptr(item->next); } template -typename NodeBuffer::ItemPtr NodeBuffer::uninitializedPtr(size_t itemOffset) { +typename NodeBuffer::ItemPtr NodeBuffer::uninitializedPtr(size_t itemOffset) noexcept { // make sure this can be read as an Item, and then use Item::size for the size std::size_t itemSpace = m_header.size - itemOffset; if (itemOffset >= sizeof(Header) && @@ -240,7 +250,7 @@ typename NodeBuffer::ItemPtr NodeBuffer::uninitializ } template -typename NodeBuffer::ItemPtr NodeBuffer::ptr(size_t itemOffset) { +typename NodeBuffer::ItemPtr NodeBuffer::ptr(size_t itemOffset) noexcept { // make sure this can be read as an Item, and then use Item::size for the size std::size_t itemSpace = m_header.size - itemOffset; auto item = reinterpret_cast(reinterpret_cast(this) + itemOffset); @@ -259,7 +269,7 @@ typename NodeBuffer::ItemPtr NodeBuffer::ptr(size_t } template -typename NodeBuffer::ItemPtr NodeBuffer::malloc(size_t size) { +typename NodeBuffer::ItemPtr NodeBuffer::malloc(size_t size) noexcept { oxTrace("ox::ptrarith::NodeBuffer::malloc") << "Size:" << size; size_t fullSize = size + sizeof(Item); if (m_header.size - m_header.bytesUsed >= fullSize) { @@ -318,7 +328,7 @@ typename NodeBuffer::ItemPtr NodeBuffer::malloc(size } template -Error NodeBuffer::free(ItemPtr item) { +Error NodeBuffer::free(ItemPtr item) noexcept { oxTrace("ox::ptrarith::NodeBuffer::free") << "offset:" << item.offset(); auto prev = this->prev(item); auto next = this->next(item); @@ -349,7 +359,7 @@ Error NodeBuffer::free(ItemPtr item) { } template -Error NodeBuffer::setSize(size_t size) { +Error NodeBuffer::setSize(size_t size) noexcept { oxTracef("ox::ptrarith::NodeBuffer::setSize", "{} to {}", m_header.size.get(), size); auto last = lastItem(); auto end = last.valid() ? last.end() : sizeof(m_header); @@ -366,28 +376,28 @@ Error NodeBuffer::setSize(size_t size) { } template -size_t NodeBuffer::size() { +constexpr size_t NodeBuffer::size() const noexcept { return m_header.size; } template -bool NodeBuffer::valid(size_t maxSize) { +bool NodeBuffer::valid(size_t maxSize) noexcept { return m_header.size <= maxSize; } template -size_t NodeBuffer::available() { +size_t NodeBuffer::available() noexcept { return m_header.size - m_header.bytesUsed; } template -size_t NodeBuffer::spaceNeeded(size_t size) { +size_t NodeBuffer::spaceNeeded(size_t size) noexcept { return sizeof(Item) + size; } template template -Error NodeBuffer::compact(F cb) { +Error NodeBuffer::compact(F cb) noexcept { auto src = firstItem(); auto dest = ptr(sizeof(*this)); while (dest.offset() <= src.offset()) { @@ -417,7 +427,7 @@ Error NodeBuffer::compact(F cb) { } template -uint8_t *NodeBuffer::data() { +uint8_t *NodeBuffer::data() noexcept { return reinterpret_cast(ptr(sizeof(*this)).get()); } diff --git a/deps/ox/src/ox/fs/ptrarith/ptr.hpp b/deps/ox/src/ox/fs/ptrarith/ptr.hpp index eb4af678..cb85e54e 100644 --- a/deps/ox/src/ox/fs/ptrarith/ptr.hpp +++ b/deps/ox/src/ox/fs/ptrarith/ptr.hpp @@ -13,7 +13,7 @@ namespace ox::ptrarith { template -class Ptr { +class [[nodiscard]] Ptr { private: uint8_t *m_dataStart = nullptr; @@ -25,65 +25,66 @@ class Ptr { mutable uint8_t m_validated = false; public: - inline Ptr() = default; + constexpr Ptr() noexcept = default; - inline Ptr(std::nullptr_t); + constexpr Ptr(std::nullptr_t) noexcept; - inline Ptr(void *dataStart, size_t dataSize, size_t itemStart, size_t itemSize = sizeof(T), size_t itemTypeSize = sizeof(T)); + constexpr Ptr(void *dataStart, size_t dataSize, size_t itemStart, size_t itemSize = sizeof(T), size_t itemTypeSize = sizeof(T)) noexcept; - [[nodiscard]] inline bool valid() const; + [[nodiscard]] + constexpr bool valid() const noexcept; - inline size_t size() const; + constexpr size_t size() const noexcept; - inline size_t offset() const; + constexpr size_t offset() const noexcept; - inline size_t end(); + constexpr size_t end() noexcept; - inline const T *get() const; + constexpr const T *get() const noexcept; - inline T *get(); + constexpr T *get() noexcept; - inline const T *operator->() const; + constexpr const T *operator->() const noexcept; - inline T *operator->(); + constexpr T *operator->() noexcept; - inline operator const T*() const; + constexpr operator const T*() const noexcept; - inline operator T*(); + constexpr operator T*() noexcept; - inline const T &operator*() const; + constexpr const T &operator*() const noexcept; - inline T &operator*(); + constexpr T &operator*() noexcept; - inline operator size_t() const; + constexpr operator size_t() const noexcept; - inline bool operator==(const Ptr &other) const; + constexpr bool operator==(const Ptr &other) const noexcept; - inline bool operator!=(const Ptr &other) const; + constexpr bool operator!=(const Ptr &other) const noexcept; template - inline const Ptr subPtr(size_t offset, size_t size) const; + constexpr const Ptr subPtr(size_t offset, size_t size) const noexcept; template - inline const Ptr subPtr(size_t offset) const; + constexpr const Ptr subPtr(size_t offset) const noexcept; template - inline Ptr subPtr(size_t offset, size_t size); + constexpr Ptr subPtr(size_t offset, size_t size) noexcept; template - inline Ptr subPtr(size_t offset); + constexpr Ptr subPtr(size_t offset) noexcept; template - inline const Ptr to() const; + constexpr const Ptr to() const noexcept; }; template -inline Ptr::Ptr(std::nullptr_t) { +constexpr Ptr::Ptr(std::nullptr_t) noexcept { } template -inline Ptr::Ptr(void *dataStart, size_t dataSize, size_t itemStart, size_t itemSize, size_t itemTypeSize) { +constexpr Ptr::Ptr(void *dataStart, size_t dataSize, size_t itemStart, size_t itemSize, size_t itemTypeSize) noexcept { // do some sanity checks before assuming this is valid if (itemSize >= itemTypeSize && dataStart && @@ -97,84 +98,84 @@ inline Ptr::Ptr(void *dataStart, size_t dataSize, size_t i } template -inline bool Ptr::valid() const { +constexpr bool Ptr::valid() const noexcept { m_validated = m_dataStart != nullptr; return m_validated; } template -inline size_t Ptr::size() const { +constexpr size_t Ptr::size() const noexcept { return m_itemSize; } template -inline size_t Ptr::offset() const { +constexpr size_t Ptr::offset() const noexcept { return m_itemOffset; } template -inline size_t Ptr::end() { +constexpr size_t Ptr::end() noexcept { return m_itemOffset + m_itemSize; } template -inline const T *Ptr::get() const { +constexpr const T *Ptr::get() const noexcept { oxAssert(m_validated, "Unvalidated pointer access. (ox::fs::Ptr::get())"); oxAssert(valid(), "Invalid pointer access. (ox::fs::Ptr::get())"); return reinterpret_cast(m_dataStart + m_itemOffset); } template -inline T *Ptr::get() { +constexpr T *Ptr::get() noexcept { oxAssert(m_validated, "Unvalidated pointer access. (ox::fs::Ptr::get())"); oxAssert(valid(), "Invalid pointer access. (ox::fs::Ptr::get())"); return reinterpret_cast(m_dataStart + m_itemOffset); } template -inline const T *Ptr::operator->() const { +constexpr const T *Ptr::operator->() const noexcept { oxAssert(m_validated, "Unvalidated pointer access. (ox::fs::Ptr::operator->())"); oxAssert(valid(), "Invalid pointer access. (ox::fs::Ptr::operator->())"); return reinterpret_cast(m_dataStart + m_itemOffset); } template -inline T *Ptr::operator->() { +constexpr T *Ptr::operator->() noexcept { oxAssert(m_validated, "Unvalidated pointer access. (ox::fs::Ptr::operator->())"); oxAssert(valid(), "Invalid pointer access. (ox::fs::Ptr::operator->())"); return reinterpret_cast(m_dataStart + m_itemOffset); } template -inline Ptr::operator const T*() const { +constexpr Ptr::operator const T*() const noexcept { oxAssert(m_validated, "Unvalidated pointer access. (ox::fs::Ptr::operator const T*())"); oxAssert(valid(), "Invalid pointer access. (ox::fs::Ptr::operator const T*())"); return reinterpret_cast(m_dataStart + m_itemOffset); } template -inline Ptr::operator T*() { +constexpr Ptr::operator T*() noexcept { oxAssert(m_validated, "Unvalidated pointer access. (ox::fs::Ptr::operator T*())"); oxAssert(valid(), "Invalid pointer access. (ox::fs::Ptr::operator T*())"); return reinterpret_cast(m_dataStart + m_itemOffset); } template -inline const T &Ptr::operator*() const { +constexpr const T &Ptr::operator*() const noexcept { oxAssert(m_validated, "Unvalidated pointer dereference. (ox::fs::Ptr::operator*())"); oxAssert(valid(), "Invalid pointer dereference. (ox::fs::Ptr::operator*())"); return *reinterpret_cast(m_dataStart + m_itemOffset); } template -inline T &Ptr::operator*() { +constexpr T &Ptr::operator*() noexcept { oxAssert(m_validated, "Unvalidated pointer dereference. (ox::fs::Ptr::operator*())"); oxAssert(valid(), "Invalid pointer dereference. (ox::fs::Ptr::operator*())"); return *reinterpret_cast(m_dataStart + m_itemOffset); } template -inline Ptr::operator size_t() const { +constexpr Ptr::operator size_t() const noexcept { if (m_dataStart && m_itemOffset) { return m_itemOffset; } @@ -182,14 +183,14 @@ inline Ptr::operator size_t() const { } template -inline bool Ptr::operator==(const Ptr &other) const { +constexpr bool Ptr::operator==(const Ptr &other) const noexcept { return m_dataStart == other.m_dataStart && m_itemOffset == other.m_itemOffset && m_itemSize == other.m_itemSize; } template -inline bool Ptr::operator!=(const Ptr &other) const { +constexpr bool Ptr::operator!=(const Ptr &other) const noexcept { return m_dataStart != other.m_dataStart || m_itemOffset != other.m_itemOffset || m_itemSize != other.m_itemSize; @@ -197,33 +198,33 @@ inline bool Ptr::operator!=(const Ptr template -inline const Ptr Ptr::subPtr(size_t offset, size_t size) const { +constexpr const Ptr Ptr::subPtr(size_t offset, size_t size) const noexcept { return Ptr(get(), this->size(), offset, size); } template template -inline const Ptr Ptr::subPtr(size_t offset) const { +constexpr const Ptr Ptr::subPtr(size_t offset) const noexcept { oxTrace("ox::fs::Ptr::subPtr") << m_itemOffset << this->size() << offset << m_itemSize << (m_itemSize - offset); return subPtr(offset, m_itemSize - offset); } template template -inline Ptr Ptr::subPtr(size_t offset, size_t size) { +constexpr Ptr Ptr::subPtr(size_t offset, size_t size) noexcept { return Ptr(get(), this->size(), offset, size); } template template -inline Ptr Ptr::subPtr(size_t offset) { +constexpr Ptr Ptr::subPtr(size_t offset) noexcept { oxTrace("ox::fs::Ptr::subPtr") << m_itemOffset << this->size() << offset << m_itemSize << (m_itemSize - offset); return subPtr(offset, m_itemSize - offset); } template template -inline const Ptr Ptr::to() const { +constexpr const Ptr Ptr::to() const noexcept { return Ptr(m_dataStart, m_dataSize, m_itemOffset, m_itemSize); }