From ca851e105927e5fcfe9467e514552f6be199d496 Mon Sep 17 00:00:00 2001 From: Gary Talent Date: Wed, 28 Jan 2026 22:55:26 -0600 Subject: [PATCH] [ox] Cleanup some expensive headers --- deps/ox/src/ox/model/modelvalue.cpp | 10 +- deps/ox/src/ox/model/modelvalue.hpp | 2 +- deps/ox/src/ox/std/CMakeLists.txt | 1 + deps/ox/src/ox/std/assert.hpp | 4 - deps/ox/src/ox/std/error.hpp | 8 +- deps/ox/src/ox/std/hashmap.hpp | 13 +- deps/ox/src/ox/std/istreamreader.cpp | 77 ++++++++ deps/ox/src/ox/std/istreamreader.hpp | 33 ++++ deps/ox/src/ox/std/reader.cpp | 69 ------- deps/ox/src/ox/std/reader.hpp | 18 -- deps/ox/src/ox/std/typetraits.hpp | 19 ++ deps/ox/src/ox/std/vector.hpp | 283 ++++++++++++++------------- 12 files changed, 291 insertions(+), 246 deletions(-) create mode 100644 deps/ox/src/ox/std/istreamreader.cpp create mode 100644 deps/ox/src/ox/std/istreamreader.hpp diff --git a/deps/ox/src/ox/model/modelvalue.cpp b/deps/ox/src/ox/model/modelvalue.cpp index 97829e5c..ea3136cc 100644 --- a/deps/ox/src/ox/model/modelvalue.cpp +++ b/deps/ox/src/ox/model/modelvalue.cpp @@ -6,19 +6,21 @@ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */ +#include + #include "modelvalue.hpp" namespace ox { -static_assert([]() -> ox::Error { - ox::ModelValue v; +static_assert([]() -> Error { + ModelValue v; OX_RETURN_ERROR(v.setType()); if (v.type() != ModelValue::Type::SignedInteger32) { - return ox::Error(1, "type is wrong"); + return Error(1, "type is wrong"); } //oxReturnError(v.set(5)); return {}; -}() == ox::Error{}); +}() == Error{}); // a dummy function to prevent linker errors in a library that has no other symbols void modelDummyFunc() noexcept {} diff --git a/deps/ox/src/ox/model/modelvalue.hpp b/deps/ox/src/ox/model/modelvalue.hpp index ac09ec53..be54059a 100644 --- a/deps/ox/src/ox/model/modelvalue.hpp +++ b/deps/ox/src/ox/model/modelvalue.hpp @@ -1174,7 +1174,7 @@ template constexpr Error ModelValue::set(const T &v) noexcept { constexpr auto type = getType(); if (m_type != type) [[unlikely]] { - return ox::Error(1, "type mismatch"); + return Error(1, "type mismatch"); } auto &value = getValue(*this); if constexpr(type == Type::Vector || type == Type::Object || diff --git a/deps/ox/src/ox/std/CMakeLists.txt b/deps/ox/src/ox/std/CMakeLists.txt index 67de0f90..bc3f9b04 100644 --- a/deps/ox/src/ox/std/CMakeLists.txt +++ b/deps/ox/src/ox/std/CMakeLists.txt @@ -33,6 +33,7 @@ add_library( concepts.cpp fmt.cpp heapmgr.cpp + istreamreader.cpp math.cpp memops.cpp random.cpp diff --git a/deps/ox/src/ox/std/assert.hpp b/deps/ox/src/ox/std/assert.hpp index b531ff48..7300fed1 100644 --- a/deps/ox/src/ox/std/assert.hpp +++ b/deps/ox/src/ox/std/assert.hpp @@ -8,10 +8,6 @@ #pragma once -#if defined(OX_USE_STDLIB) -#include -#endif - #include "def.hpp" #include "defines.hpp" #include "error.hpp" diff --git a/deps/ox/src/ox/std/error.hpp b/deps/ox/src/ox/std/error.hpp index ef0d7bbe..e440f7bb 100644 --- a/deps/ox/src/ox/std/error.hpp +++ b/deps/ox/src/ox/std/error.hpp @@ -89,7 +89,7 @@ constexpr auto toStr(Error const &err) noexcept { struct Exception: public std::exception { std::source_location src; - ox::CString msg = nullptr; + CString msg = nullptr; ErrorCode errCode = 0; explicit Exception( @@ -100,7 +100,7 @@ struct Exception: public std::exception { explicit Exception( ErrorCode const errCode, - ox::CString msg, + CString msg, std::source_location const &src = std::source_location::current()) noexcept: src{src}, msg{msg}, @@ -221,7 +221,7 @@ struct [[nodiscard]] Result { [[nodiscard]] constexpr T &unwrapThrow() & { if (error) { - throw ox::Exception(error); + throw Exception(error); } return value; } @@ -229,7 +229,7 @@ struct [[nodiscard]] Result { [[nodiscard]] constexpr T &&unwrapThrow() && { if (error) { - throw ox::Exception(error); + throw Exception(error); } return std::move(value); } diff --git a/deps/ox/src/ox/std/hashmap.hpp b/deps/ox/src/ox/std/hashmap.hpp index 14a53927..5f9b81d4 100644 --- a/deps/ox/src/ox/std/hashmap.hpp +++ b/deps/ox/src/ox/std/hashmap.hpp @@ -106,9 +106,10 @@ constexpr bool HashMap::operator==(HashMap const &other) const { if (m_keys != other.m_keys) { return false; } - for (int i = 0; i < m_keys.size(); ++i) { - auto &k = m_keys[i]; - if (at(k) != other.at(k)) { + for (auto &k : m_keys) { + auto const a = at(k).value; + auto const b = other.at(k).value; + if (a && b && *a != *b) { return false; } } @@ -196,7 +197,7 @@ constexpr std::size_t HashMap::size() const noexcept { } template -constexpr Vector const&HashMap::keys() const noexcept { +constexpr Vector const &HashMap::keys() const noexcept { return m_keys; } @@ -205,8 +206,8 @@ constexpr Vector HashMap::values() const noexcept { Vector out; out.reserve(m_keys.size()); for (auto const &p : m_pairs) { - if (out) { - out.emplace_back(p->value); + if (p) { + out.emplace_back(*p->value); } } return out; diff --git a/deps/ox/src/ox/std/istreamreader.cpp b/deps/ox/src/ox/std/istreamreader.cpp new file mode 100644 index 00000000..3eaa9418 --- /dev/null +++ b/deps/ox/src/ox/std/istreamreader.cpp @@ -0,0 +1,77 @@ +/* + * Copyright 2015 - 2025 gary@drinkingtea.net + * + * 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/. + */ + + +#ifdef OX_USE_STDLIB +#include + +#include "array.hpp" +#include "reader.hpp" +#include "istreamreader.hpp" + +namespace ox { + +[[nodiscard]] +constexpr std::ios_base::seekdir sdMap(ox::ios_base::seekdir in) noexcept { + switch (in) { + case ox::ios_base::beg: + return std::ios_base::beg; + case ox::ios_base::end: + return std::ios_base::end; + case ox::ios_base::cur: + return std::ios_base::cur; + } + return std::ios_base::beg; +} + +Result StreamReader::peek() const noexcept { + try { + if (m_strm.eof()) { + return Error{1, "EOF"}; + } + char c{}; + m_strm.get(c); + if (m_strm.unget()) [[unlikely]] { + return ox::Error{1, "Unable to unget character"}; + } + return static_cast(c); + } catch (std::exception const&) { + return ox::Error(1, "peek failed"); + } +} + +Result StreamReader::read(char *v, size_t cnt) noexcept { + return static_cast(m_strm.read(v, static_cast(cnt)).gcount()); +} + +Error StreamReader::seekg(size_t p) noexcept { + try { + m_strm.seekg(static_cast(p), std::ios_base::cur); + } catch (std::exception const&) { + return ox::Error(1, "seekg failed"); + } + return {}; +} + +Error StreamReader::seekg(int64_t p, ios_base::seekdir sd) noexcept { + try { + m_strm.seekg(p, sdMap(sd)); + } catch (std::exception const&) { + return ox::Error(1, "seekg failed"); + } + return {}; +} + +Result StreamReader::tellg() noexcept { + const auto sz = m_strm.tellg(); + return {static_cast(sz), ox::Error(sz == -1)}; +} + +} + +#endif diff --git a/deps/ox/src/ox/std/istreamreader.hpp b/deps/ox/src/ox/std/istreamreader.hpp new file mode 100644 index 00000000..3980d045 --- /dev/null +++ b/deps/ox/src/ox/std/istreamreader.hpp @@ -0,0 +1,33 @@ +/* + * Copyright 2015 - 2025 gary@drinkingtea.net + * + * 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 + +#ifdef OX_USE_STDLIB +#include +#endif + +#include "reader.hpp" + +namespace ox { + +#ifdef OX_USE_STDLIB +class StreamReader: public Reader_v { + private: + std::istream &m_strm; + public: + constexpr explicit StreamReader(std::istream &stream) noexcept: m_strm(stream) {} + Result peek() const noexcept override; + Result read(char *v, size_t cnt) noexcept override; + Error seekg(size_t p) noexcept override; + Error seekg(int64_t p, ios_base::seekdir sd) noexcept override; + Result tellg() noexcept override; +}; +#endif + +} diff --git a/deps/ox/src/ox/std/reader.cpp b/deps/ox/src/ox/std/reader.cpp index 13acc66a..5f6be8c9 100644 --- a/deps/ox/src/ox/std/reader.cpp +++ b/deps/ox/src/ox/std/reader.cpp @@ -5,72 +5,3 @@ * 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/. */ - - -#ifdef OX_USE_STDLIB -#include - -#include "array.hpp" -#include "reader.hpp" - -namespace ox { - -[[nodiscard]] -constexpr std::ios_base::seekdir sdMap(ox::ios_base::seekdir in) noexcept { - switch (in) { - case ox::ios_base::beg: - return std::ios_base::beg; - case ox::ios_base::end: - return std::ios_base::end; - case ox::ios_base::cur: - return std::ios_base::cur; - } - return std::ios_base::beg; -} - -ox::Result StreamReader::peek() const noexcept { - try { - if (m_strm.eof()) { - return Error{1, "EOF"}; - } - char c{}; - m_strm.get(c); - if (m_strm.unget()) [[unlikely]] { - return ox::Error{1, "Unable to unget character"}; - } - return static_cast(c); - } catch (std::exception const&) { - return ox::Error(1, "peek failed"); - } -} - -ox::Result StreamReader::read(char *v, std::size_t cnt) noexcept { - return static_cast(m_strm.read(v, static_cast(cnt)).gcount()); -} - -ox::Error StreamReader::seekg(std::size_t p) noexcept { - try { - m_strm.seekg(static_cast(p), std::ios_base::cur); - } catch (std::exception const&) { - return ox::Error(1, "seekg failed"); - } - return {}; -} - -ox::Error StreamReader::seekg(int64_t p, ios_base::seekdir sd) noexcept { - try { - m_strm.seekg(p, sdMap(sd)); - } catch (std::exception const&) { - return ox::Error(1, "seekg failed"); - } - return {}; -} - -ox::Result StreamReader::tellg() noexcept { - const auto sz = m_strm.tellg(); - return {static_cast(sz), ox::Error(sz == -1)}; -} - -} - -#endif diff --git a/deps/ox/src/ox/std/reader.hpp b/deps/ox/src/ox/std/reader.hpp index 5a6a1cd8..8f4e13f1 100644 --- a/deps/ox/src/ox/std/reader.hpp +++ b/deps/ox/src/ox/std/reader.hpp @@ -8,10 +8,6 @@ #pragma once -#ifdef OX_USE_STDLIB -#include -#endif - #include "concepts.hpp" #include "error.hpp" #include "types.hpp" @@ -63,18 +59,4 @@ class ReaderT: public Reader_v { } }; -#ifdef OX_USE_STDLIB -class StreamReader: public Reader_v { - private: - std::istream &m_strm; - public: - constexpr explicit StreamReader(std::istream &stream) noexcept: m_strm(stream) {} - ox::Result peek() const noexcept override; - ox::Result read(char *v, std::size_t cnt) noexcept override; - ox::Error seekg(std::size_t p) noexcept override; - ox::Error seekg(int64_t p, ios_base::seekdir sd) noexcept override; - ox::Result tellg() noexcept override; -}; -#endif - } diff --git a/deps/ox/src/ox/std/typetraits.hpp b/deps/ox/src/ox/std/typetraits.hpp index 1d25fd3d..cbc8443a 100644 --- a/deps/ox/src/ox/std/typetraits.hpp +++ b/deps/ox/src/ox/std/typetraits.hpp @@ -309,6 +309,25 @@ template constexpr bool is_move_constructible_v = detail::is_move_constructible(0); +namespace detail { +template +T const &declvalCopy(); + +template()))> +constexpr bool is_copy_constructible(int) { + return true; +} + +template +constexpr bool is_copy_constructible(bool) { + return false; +} +} + +template +constexpr bool is_copy_constructible_v = detail::is_copy_constructible(0); + + // is String? template diff --git a/deps/ox/src/ox/std/vector.hpp b/deps/ox/src/ox/std/vector.hpp index 5c3f3c83..1115cdaf 100644 --- a/deps/ox/src/ox/std/vector.hpp +++ b/deps/ox/src/ox/std/vector.hpp @@ -26,7 +26,7 @@ namespace ox { namespace detail { -template +template struct VectorAllocator { static_assert(sizeof(AllocAlias) == sizeof(T)); static_assert(alignof(AllocAlias) == alignof(T)); @@ -37,7 +37,7 @@ struct VectorAllocator { constexpr VectorAllocator(VectorAllocator const&) noexcept = default; constexpr VectorAllocator(VectorAllocator&&) noexcept = default; - constexpr void allocate(T **items, std::size_t const cap) noexcept { + constexpr void allocate(T **items, size_t const cap) noexcept { // small vector optimization cannot be done it constexpr, but it doesn't really matter in constexpr if (std::is_constant_evaluated() || cap > Size) { *items = Allocator{}.allocate(cap); @@ -49,8 +49,8 @@ struct VectorAllocator { constexpr void moveConstructItemsFrom( T **items, VectorAllocator *src, - std::size_t const count, - std::size_t const cap) noexcept { + size_t const count, + size_t const cap) noexcept { // this totally idiotic redundant check (&& count <= Size) is required to address a bug in devkitARM, // try removing it later if (!std::is_constant_evaluated()) { @@ -68,7 +68,7 @@ struct VectorAllocator { } } - constexpr void deallocate(T *const items, std::size_t const cap) noexcept { + constexpr void deallocate(T *const items, size_t const cap) noexcept { // small vector optimization cannot be done it constexpr, but it doesn't really matter in constexpr if (std::is_constant_evaluated()) { if (items) { @@ -90,7 +90,7 @@ struct VectorAllocator { constexpr VectorAllocator(VectorAllocator const&) noexcept = default; constexpr VectorAllocator(VectorAllocator&&) noexcept = default; - constexpr void allocate(T **items, std::size_t const cap) noexcept { + constexpr void allocate(T **items, size_t const cap) noexcept { *items = Allocator{}.allocate(cap); } @@ -98,15 +98,15 @@ struct VectorAllocator { constexpr void moveConstructItemsFrom( T**, VectorAllocator*, - std::size_t const, - std::size_t const) noexcept { + size_t const, + size_t const) noexcept { } [[maybe_unused]] - constexpr void moveItemsFrom(T**, VectorAllocator*, std::size_t const, std::size_t const) noexcept { + constexpr void moveItemsFrom(T**, VectorAllocator*, size_t const, size_t const) noexcept { } - constexpr void deallocate(T *const items, std::size_t const cap) noexcept { + constexpr void deallocate(T *const items, size_t const cap) noexcept { if (items) { Allocator{}.deallocate(items, cap); } @@ -116,12 +116,12 @@ struct VectorAllocator { } -template> +template> class Vector: detail::VectorAllocator { public: using value_type = T; - using size_type = std::size_t; + using size_type = size_t; template using iterator = SpanIterator; @@ -129,18 +129,18 @@ class Vector: detail::VectorAllocator { private: static constexpr auto initialCap = SmallVectorSize > 0 ? SmallVectorSize : 50; static constexpr auto useNoexcept = ox::is_integral_v || ox::is_pointer_v; - std::size_t m_size = 0; - std::size_t m_cap = 0; + size_t m_size = 0; + size_t m_cap = 0; T *m_items = nullptr; public: constexpr Vector() noexcept = default; - explicit constexpr Vector(std::size_t size) noexcept; + explicit constexpr Vector(size_t size) noexcept; constexpr Vector(std::initializer_list list) noexcept; - constexpr Vector(const Vector &other) noexcept(useNoexcept); + constexpr Vector(Vector const &other) noexcept(useNoexcept); constexpr Vector(Vector &&other) noexcept; @@ -155,23 +155,23 @@ class Vector: detail::VectorAllocator { } [[nodiscard]] - constexpr iterator begin() const noexcept { - return iterator(m_items, 0, m_size); + constexpr iterator begin() const noexcept { + return iterator(m_items, 0, m_size); } [[nodiscard]] - constexpr iterator end() const noexcept { - return iterator(m_items, m_size, m_size); + constexpr iterator end() const noexcept { + return iterator(m_items, m_size, m_size); } [[nodiscard]] - constexpr iterator cbegin() const noexcept { - return iterator(m_items, 0, m_size); + constexpr iterator cbegin() const noexcept { + return iterator(m_items, 0, m_size); } [[nodiscard]] - constexpr iterator cend() const noexcept { - return iterator(m_items, m_size, m_size); + constexpr iterator cend() const noexcept { + return iterator(m_items, m_size, m_size); } [[nodiscard]] @@ -185,36 +185,36 @@ class Vector: detail::VectorAllocator { } [[nodiscard]] - constexpr iterator crbegin() const noexcept { - return iterator(m_items, m_size - 1, m_size); + constexpr iterator crbegin() const noexcept { + return iterator(m_items, m_size - 1, m_size); } [[nodiscard]] - constexpr iterator crend() const noexcept { - return iterator(m_items, MaxValue, m_size); + constexpr iterator crend() const noexcept { + return iterator(m_items, MaxValue, m_size); } [[nodiscard]] - constexpr iterator rbegin() const noexcept { - return iterator(m_items, m_size - 1, m_size); + constexpr iterator rbegin() const noexcept { + return iterator(m_items, m_size - 1, m_size); } [[nodiscard]] - constexpr iterator rend() const noexcept { - return iterator(m_items, MaxValue, m_size); + constexpr iterator rend() const noexcept { + return iterator(m_items, MaxValue, m_size); } - constexpr bool operator==(const Vector &other) const noexcept(useNoexcept); + constexpr bool operator==(Vector const &other) const noexcept(useNoexcept); - constexpr Vector &operator=(const Vector &other) noexcept(useNoexcept); + constexpr Vector &operator=(Vector const &other) noexcept(useNoexcept); constexpr Vector &operator=(Vector &&other) noexcept; [[nodiscard]] - constexpr T &operator[](std::size_t i) noexcept; + constexpr T &operator[](size_t i) noexcept; [[nodiscard]] - constexpr const T &operator[](std::size_t i) const noexcept; + constexpr T const &operator[](size_t i) const noexcept; [[nodiscard]] constexpr Result at(size_t i) noexcept; @@ -226,28 +226,28 @@ class Vector: detail::VectorAllocator { constexpr Result front() noexcept; [[nodiscard]] - constexpr Result front() const noexcept; + constexpr Result front() const noexcept; [[nodiscard]] constexpr Result back() noexcept; [[nodiscard]] - constexpr Result back() const noexcept; + constexpr Result back() const noexcept; [[nodiscard]] - constexpr std::size_t capacity() const noexcept; + constexpr size_t capacity() const noexcept; [[nodiscard]] - constexpr std::size_t size() const noexcept; + constexpr size_t size() const noexcept; [[nodiscard]] constexpr bool empty() const noexcept; constexpr void clear() noexcept(useNoexcept); - constexpr void resize(std::size_t size) noexcept(useNoexcept); + constexpr void resize(size_t size) noexcept(useNoexcept); - constexpr void reserveResize(std::size_t size) noexcept(useNoexcept); + constexpr void reserveResize(size_t size) noexcept(useNoexcept); [[nodiscard]] constexpr T *data() noexcept { @@ -255,7 +255,7 @@ class Vector: detail::VectorAllocator { } [[nodiscard]] - constexpr const T *data() const noexcept { + constexpr T const *data() const noexcept { return m_items; } @@ -263,12 +263,12 @@ class Vector: detail::VectorAllocator { constexpr bool contains(MaybeView_t const&) const noexcept; constexpr iterator insert( - std::size_t pos, std::size_t cnt, T const &val) noexcept(useNoexcept); + size_t pos, size_t cnt, T const &val) noexcept(useNoexcept); - constexpr iterator insert(std::size_t pos, T val) noexcept(useNoexcept); + constexpr iterator insert(size_t pos, T val) noexcept(useNoexcept); template - constexpr iterator emplace(std::size_t pos, Args&&... args) noexcept(useNoexcept); + constexpr iterator emplace(size_t pos, Args&&... args) noexcept(useNoexcept); template constexpr T &emplace_back(Args&&... args) noexcept(useNoexcept); @@ -284,14 +284,14 @@ class Vector: detail::VectorAllocator { * @param pos iterator at the point to remove * @return Error if index is out of bounds */ - constexpr Result> erase(const iterator<> &pos) noexcept(useNoexcept); + constexpr Result> erase(iterator<> const &pos) noexcept(useNoexcept); /** * 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) noexcept(useNoexcept); + constexpr Result> erase(size_t pos) noexcept(useNoexcept); /** * Moves the last item in the Vector to position pos and decrements the @@ -299,59 +299,62 @@ 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) noexcept(useNoexcept); + constexpr Error unordered_erase(size_t pos) noexcept(useNoexcept); constexpr Error remove(MaybeView_t const &val); - constexpr void reserve(std::size_t cap) noexcept(useNoexcept); + constexpr void reserve(size_t cap) noexcept(useNoexcept); constexpr void shrink_to_fit() noexcept(useNoexcept); private: constexpr void reserveInsert( - std::size_t cap, std::size_t pos, std::size_t offset = 1) noexcept(useNoexcept); + size_t cap, size_t pos, size_t offset = 1) noexcept(useNoexcept); }; -template +template using VectorIt = typename Vector::template iterator; -template +template constexpr VectorIt operator+( - std::size_t n, - const VectorIt &a) { + size_t n, + VectorIt const &a) { return a + n; } -template -constexpr Vector::Vector(std::size_t size) noexcept { +template +constexpr Vector::Vector(size_t const size) noexcept { m_size = size; m_cap = m_size; this->allocate(&m_items, m_cap); - for (std::size_t i = 0; i < size; ++i) { + for (size_t i = 0; i < size; ++i) { std::construct_at(&m_items[i]); } } -template +template constexpr Vector::Vector(std::initializer_list list) noexcept { - reserve(list.size()); - for (auto &item : list) { - emplace_back(std::move(item)); + m_size = list.size(); + m_cap = m_size; + this->allocate(&m_items, m_cap); + for (size_t i{}; auto &item : list) { + std::construct_at(&m_items[i], std::move(item)); + ++i; } } -template -constexpr Vector::Vector(const Vector &other) noexcept(useNoexcept) { +template +constexpr Vector::Vector(Vector const &other) noexcept(useNoexcept) { m_size = other.m_size; m_cap = other.m_cap; this->allocate(&m_items, other.m_cap); - for (std::size_t i = 0; i < m_size; ++i) { + for (size_t i = 0; i < m_size; ++i) { std::construct_at(&m_items[i], other.m_items[i]); } } -template +template constexpr Vector::Vector(Vector &&other) noexcept { m_size = other.m_size; m_cap = other.m_cap; @@ -362,20 +365,20 @@ constexpr Vector::Vector(Vector &&other) noexcept other.m_items = nullptr; } -template +template constexpr Vector::~Vector() { clear(); this->deallocate(m_items, m_cap); m_items = nullptr; } -template +template constexpr bool Vector::operator==( - const Vector &other) const noexcept(useNoexcept) { + Vector const &other) const noexcept(useNoexcept) { if (m_size != other.m_size) { return false; } - for (std::size_t i = 0; i < m_size; i++) { + for (size_t i = 0; i < m_size; i++) { if (!(m_items[i] == other.m_items[i])) { return false; } @@ -383,9 +386,9 @@ constexpr bool Vector::operator==( return true; } -template +template constexpr Vector &Vector::operator=( - const Vector &other) noexcept(useNoexcept) { + Vector const &other) noexcept(useNoexcept) { if (this != &other) { clear(); this->deallocate(m_items, m_cap); @@ -393,14 +396,14 @@ constexpr Vector &Vectorallocate(&m_items, other.m_cap); - for (std::size_t i = 0; i < m_size; i++) { + for (size_t i = 0; i < m_size; i++) { std::construct_at(&m_items[i], other.m_items[i]); } } return *this; } -template +template constexpr Vector &Vector::operator=( Vector &&other) noexcept { if (this != &other) { @@ -417,35 +420,35 @@ constexpr Vector &Vector -constexpr T &Vector::operator[](std::size_t i) noexcept { +template +constexpr T &Vector::operator[](size_t const i) noexcept { boundsCheck(i, size(), "Vector access overflow"); return m_items[i]; } -template -constexpr const T &Vector::operator[](std::size_t i) const noexcept { +template +constexpr T const &Vector::operator[](size_t const i) const noexcept { boundsCheck(i, size(), "Vector access overflow"); return m_items[i]; } -template -constexpr Result Vector::at(size_t i) noexcept { +template +constexpr Result Vector::at(size_t const i) noexcept { if (i < size()) [[likely]] { return &operator[](i); } return ox::Error(1, "Vector: Invalid index"); } -template -constexpr Result Vector::at(size_t i) const noexcept { +template +constexpr Result Vector::at(size_t const i) const noexcept { if (i < size()) [[likely]] { return &operator[](i); } return ox::Error(1, "Vector: Invalid index"); } -template +template constexpr Result Vector::front() noexcept { if (!m_size) { return {nullptr, ox::Error(1)}; @@ -453,15 +456,15 @@ constexpr Result Vector::front() noexcept { return &m_items[0]; } -template -constexpr Result Vector::front() const noexcept { +template +constexpr Result Vector::front() const noexcept { if (!m_size) { return {nullptr, ox::Error(1)}; } return &m_items[0]; } -template +template constexpr Result Vector::back() noexcept { if (!m_size) { return {nullptr, ox::Error(1)}; @@ -469,65 +472,65 @@ constexpr Result Vector::back() noexcept { return &m_items[m_size - 1]; } -template -constexpr Result Vector::back() const noexcept { +template +constexpr Result Vector::back() const noexcept { if (!m_size) { return {nullptr, ox::Error(1)}; } return &m_items[m_size - 1]; } -template -constexpr std::size_t Vector::capacity() const noexcept { +template +constexpr size_t Vector::capacity() const noexcept { return m_cap; } -template -constexpr std::size_t Vector::size() const noexcept { +template +constexpr size_t Vector::size() const noexcept { return m_size; } -template +template constexpr bool Vector::empty() const noexcept { return !m_size; } -template +template constexpr void Vector::clear() noexcept(useNoexcept) { if constexpr(is_class()) { - for (std::size_t i = 0; i < m_size; ++i) { + for (size_t i = 0; i < m_size; ++i) { m_items[i].~T(); } } m_size = 0; } -template -constexpr void Vector::resize(std::size_t size) noexcept(useNoexcept) { +template +constexpr void Vector::resize(size_t const size) noexcept(useNoexcept) { if (m_cap < size) { reserve(size * 2); } if (m_size < size) { - for (std::size_t i = m_size; i < size; i++) { + for (size_t i = m_size; i < size; i++) { std::construct_at(&m_items[i]); } } else { - for (std::size_t i = size; i < m_size; i++) { + for (size_t i = size; i < m_size; i++) { m_items[i].~T(); } } m_size = size; } -template -constexpr void Vector::reserveResize(std::size_t const size) noexcept(useNoexcept) { +template +constexpr void Vector::reserveResize(size_t const size) noexcept(useNoexcept) { reserve(size); resize(size); } -template +template constexpr bool Vector::contains(MaybeView_t const &v) const noexcept { - for (std::size_t i = 0; i < m_size; ++i) { + for (size_t i = 0; i < m_size; ++i) { if (m_items[i] == v) { return true; } @@ -535,10 +538,10 @@ constexpr bool Vector::contains(MaybeView_t co return false; } -template +template constexpr typename Vector::template iterator Vector::insert( - std::size_t pos, std::size_t cnt, T const &val) noexcept(useNoexcept) { + size_t const pos, size_t const cnt, T const &val) noexcept(useNoexcept) { if (m_size + cnt > m_cap) { reserveInsert(m_cap ? m_size + cnt : initialCap, pos, cnt); } @@ -558,9 +561,9 @@ Vector::insert( return begin() + pos; } -template +template constexpr typename Vector::template iterator -Vector::insert(std::size_t pos, T val) noexcept(useNoexcept) { +Vector::insert(size_t pos, T val) noexcept(useNoexcept) { if (m_size == m_cap) { reserveInsert(m_cap ? m_cap * 2 : initialCap, pos); } @@ -576,10 +579,10 @@ Vector::insert(std::size_t pos, T val) noexcept(u return begin() + pos; } -template +template template constexpr typename Vector::template iterator -Vector::emplace(std::size_t pos, Args&&... args) noexcept(useNoexcept) { +Vector::emplace(size_t pos, Args&&... args) noexcept(useNoexcept) { if (m_size == m_cap) { reserveInsert(m_cap ? m_cap * 2 : initialCap, pos); if (pos < m_size) { @@ -599,7 +602,7 @@ Vector::emplace(std::size_t pos, Args&&... args) return begin() + pos; } -template +template template constexpr T &Vector::emplace_back(Args&&... args) noexcept(useNoexcept) { if (m_size == m_cap) { @@ -610,7 +613,7 @@ constexpr T &Vector::emplace_back(Args&&... args) return *out; } -template +template constexpr void Vector::push_back(T const &item) noexcept(useNoexcept) { if (m_size == m_cap) { reserve(m_cap ? m_cap * 2 : initialCap); @@ -619,7 +622,7 @@ constexpr void Vector::push_back(T const &item) n ++m_size; } -template +template constexpr void Vector::push_back(T &&item) noexcept(useNoexcept) { if (m_size == m_cap) { reserve(m_cap ? m_cap * 2 : initialCap); @@ -628,21 +631,21 @@ constexpr void Vector::push_back(T &&item) noexce ++m_size; } -template +template constexpr void Vector::pop_back() noexcept(useNoexcept) { --m_size; m_items[m_size].~T(); } -template +template constexpr Result::template iterator> -Vector::erase(const iterator<> &pos) noexcept(useNoexcept) { +Vector::erase(iterator<> const &pos) noexcept(useNoexcept) { return erase(pos.offset()); } -template +template constexpr Result::template iterator> -Vector::erase(std::size_t pos) noexcept(useNoexcept) { +Vector::erase(size_t pos) noexcept(useNoexcept) { if (pos >= m_size) { return ox::Error(1, "Vector::erase failed: pos is greater than Vector size"); } @@ -654,8 +657,8 @@ Vector::erase(std::size_t pos) noexcept(useNoexce return begin() + pos; } -template -constexpr Error Vector::unordered_erase(std::size_t pos) +template +constexpr Error Vector::unordered_erase(size_t pos) noexcept(useNoexcept) { if (pos >= m_size) { return ox::Error(1); @@ -666,7 +669,7 @@ constexpr Error Vector::unordered_erase(std::size return {}; } -template +template constexpr ox::Error Vector::remove(MaybeView_t const &val) { for (size_t i{}; auto const &v : *this) { if (v == val) { @@ -677,18 +680,18 @@ constexpr ox::Error Vector::remove(MaybeView_t return ox::Error{1, "element not found"}; } -template -constexpr void Vector::reserve(std::size_t cap) noexcept(useNoexcept) { +template +constexpr void Vector::reserve(size_t cap) noexcept(useNoexcept) { if (cap <= m_cap) { return; } - const auto oldItems = m_items; - const auto oldCap = m_cap; + auto const oldItems = m_items; + auto const oldCap = m_cap; m_cap = cap; this->allocate(&m_items, cap); if (oldItems) { // move over old items - const auto itRange = ox::min(cap, m_size); - for (std::size_t i = 0; i < itRange; ++i) { + auto const itRange = ox::min(cap, m_size); + for (size_t i = 0; i < itRange; ++i) { std::construct_at(&m_items[i], std::move(oldItems[i])); oldItems[i].~T(); } @@ -696,17 +699,17 @@ constexpr void Vector::reserve(std::size_t cap) n } } -template +template constexpr void Vector::shrink_to_fit() noexcept(useNoexcept) { if (m_size == m_cap) { return; } - const auto oldItems = m_items; - const auto oldCap = m_cap; + auto const oldItems = m_items; + auto const oldCap = m_cap; m_cap = m_size; this->allocate(&m_items, m_size); if (oldItems) { // move over old items - for (std::size_t i = 0; i < m_size; ++i) { + for (size_t i = 0; i < m_size; ++i) { std::construct_at(&m_items[i], std::move(oldItems[i])); oldItems[i].~T(); } @@ -714,26 +717,26 @@ constexpr void Vector::shrink_to_fit() noexcept(u } } -template +template constexpr void Vector::reserveInsert( - std::size_t cap, - std::size_t pos, - std::size_t offset) noexcept(useNoexcept) { + size_t cap, + size_t pos, + size_t offset) noexcept(useNoexcept) { if (cap <= m_cap) { return; } - const auto oldItems = m_items; - const auto oldCap = m_cap; + auto const oldItems = m_items; + auto const oldCap = m_cap; m_cap = cap; this->allocate(&m_items, cap); if (oldItems) { // move over old items auto itRange = ox::min(m_size, pos); - for (std::size_t i = 0; i < itRange; ++i) { + for (size_t i = 0; i < itRange; ++i) { std::construct_at(&m_items[i], std::move(oldItems[i])); oldItems[i].~T(); } itRange = m_size; - for (std::size_t i = pos; i < itRange; ++i) { + for (size_t i = pos; i < itRange; ++i) { std::construct_at(&m_items[i + offset], std::move(oldItems[i])); oldItems[i].~T(); } @@ -744,8 +747,8 @@ constexpr void Vector::reserveInsert( template [[nodiscard]] -constexpr auto alignOf(const Vector&) noexcept { - const typename PlatSpec::size_t i = 0; +constexpr auto alignOf(Vector const&) noexcept { + typename PlatSpec::size_t const i = 0; return PlatSpec::alignOf(i); }