More noexcept usage

Author: ZeroMemes

include/libhat/access.hpp

@@ -8,7 +8,7 @@
 namespace hat {
 
     template<typename MemberType, typename Base>
-    auto& member_at(Base* ptr, std::integral auto offset) {
+    auto& member_at(Base* ptr, std::integral auto offset) noexcept {
         using Ret = hat::constness_as_t<MemberType, Base>;
         return *reinterpret_cast<Ret*>(reinterpret_cast<std::uintptr_t>(ptr) + offset);
     }

include/libhat/defines.hpp

@@ -16,7 +16,7 @@
     #include <intrin.h>
 
     namespace hat::detail {
-        inline unsigned long bsf(unsigned long num) {
+        inline unsigned long bsf(unsigned long num) noexcept {
             unsigned long offset;
             _BitScanForward(&offset, num);
             return offset;
@@ -59,7 +59,7 @@
 #else
     #include <cstdlib>
     namespace hat::detail {
-        [[noreturn]] inline void unreachable_impl() {
+        [[noreturn]] inline void unreachable_impl() noexcept {
             std::abort();
         }
     }

include/libhat/fixed_string.hpp

@@ -26,83 +26,83 @@ namespace hat {
             std::copy_n(str, N, value);
         }
 
-        [[nodiscard]] constexpr iterator begin() {
+        [[nodiscard]] constexpr iterator begin() noexcept {
             return this->c_str();
         }
 
-        [[nodiscard]] constexpr iterator end() {
+        [[nodiscard]] constexpr iterator end() noexcept {
             return this->begin() + this->size();
         }
 
-        [[nodiscard]] constexpr const_iterator begin() const {
+        [[nodiscard]] constexpr const_iterator begin() const noexcept {
             return this->c_str();
         }
 
-        [[nodiscard]] constexpr const_iterator end() const {
+        [[nodiscard]] constexpr const_iterator end() const noexcept {
             return this->begin() + this->size();
         }
 
-        [[nodiscard]] constexpr const_iterator cbegin() const {
+        [[nodiscard]] constexpr const_iterator cbegin() const noexcept {
             return this->begin();
         }
 
-        [[nodiscard]] constexpr const_iterator cend() const {
+        [[nodiscard]] constexpr const_iterator cend() const noexcept {
             return this->end();
         }
 
-        [[nodiscard]] constexpr reference operator[](size_t pos) {
+        [[nodiscard]] constexpr reference operator[](size_t pos) noexcept {
             return this->value[pos];
         }
 
-        [[nodiscard]] constexpr reference at(size_t pos) {
+        [[nodiscard]] constexpr reference at(size_t pos) noexcept {
             return this->value[pos];
         }
 
-        [[nodiscard]] constexpr const_reference operator[](size_t pos) const {
+        [[nodiscard]] constexpr const_reference operator[](size_t pos) const noexcept {
             return this->value[pos];
         }
 
-        [[nodiscard]] constexpr const_reference at(size_t pos) const {
+        [[nodiscard]] constexpr const_reference at(size_t pos) const noexcept {
             return this->value[pos];
         }
 
-        [[nodiscard]] constexpr reference front() {
+        [[nodiscard]] constexpr reference front() noexcept {
             return this->value[0];
         }
 
-        [[nodiscard]] constexpr reference back() {
+        [[nodiscard]] constexpr reference back() noexcept {
             return this->value[size() - 1];
         }
 
-        [[nodiscard]] constexpr const_reference front() const {
+        [[nodiscard]] constexpr const_reference front() const noexcept {
             return this->value[0];
         }
 
-        [[nodiscard]] constexpr const_reference back() const {
+        [[nodiscard]] constexpr const_reference back() const noexcept {
             return this->value[size() - 1];
         }
 
-        [[nodiscard]] constexpr pointer c_str() {
+        [[nodiscard]] constexpr pointer c_str() noexcept {
             return static_cast<Char*>(this->value);
         }
 
-        [[nodiscard]] constexpr const_pointer c_str() const {
+        [[nodiscard]] constexpr const_pointer c_str() const noexcept {
             return static_cast<const Char*>(this->value);
         }
 
-        [[nodiscard]] constexpr pointer data() {
+        [[nodiscard]] constexpr pointer data() noexcept {
             return this->c_str();
         }
 
-        [[nodiscard]] constexpr const_pointer data() const {
+        [[nodiscard]] constexpr const_pointer data() const noexcept {
             return this->c_str();
         }
 
-        [[nodiscard]] constexpr size_t size() const {
+        [[nodiscard]] constexpr size_t size() const noexcept {
             return N;
         }
 
-        [[nodiscard]] constexpr bool empty() const {
+        [[nodiscard]] constexpr bool empty() const noexcept {
             return this->size() == 0;
         }
 

include/libhat/memory_protector.hpp

@@ -12,12 +12,12 @@ namespace hat {
         Execute = 0b100
     };
 
-    constexpr protection operator|(protection lhs, protection rhs) {
+    constexpr protection operator|(protection lhs, protection rhs) noexcept {
         using U = std::underlying_type_t<protection>;
         return static_cast<protection>(static_cast<U>(lhs) | static_cast<U>(rhs));
     }
 
-    constexpr protection operator&(protection lhs, protection rhs) {
+    constexpr protection operator&(protection lhs, protection rhs) noexcept {
         using U = std::underlying_type_t<protection>;
         return static_cast<protection>(static_cast<U>(lhs) & static_cast<U>(rhs));
     }
@@ -39,12 +39,12 @@ namespace hat {
             oldProtection(o.oldProtection),
             set(std::exchange(o.set, false)) {}
 
-        memory_protector& operator=(memory_protector&& o) noexcept = delete;
+        memory_protector& operator=(memory_protector&& o) = delete;
         memory_protector(const memory_protector&) = delete;
         memory_protector& operator=(const memory_protector&) = delete;
 
         /// Returns true if the memory protect operation was successful
-        [[nodiscard]] bool is_set() const {
+        [[nodiscard]] bool is_set() const noexcept {
             return this->set;
         }
 

include/libhat/process.hpp

@@ -21,6 +21,7 @@ namespace hat::process {
 
         /// Returns the memory region for a named section
         [[nodiscard]] std::span<std::byte> get_section_data(std::string_view name) const;
+
     private:
         explicit module(const uintptr_t baseAddress)
             : baseAddress(baseAddress) {}