Remove reinterpret_cast usage in favor of std::bit_cast.

10 files changed, 71 insertions, 101 deletions

diff --git a/include/fud_c_string.hpp b/include/fud_c_string.hpp
index a1ab51a..0632619 100644
--- a/include/fud_c_string.hpp
+++ b/include/fud_c_string.hpp
@@ -18,6 +18,7 @@
 #ifndef FUD_C_STRING_HPP
 #define FUD_C_STRING_HPP
 
+#include <bit>
 #include <climits>
 #include <cstddef>
 #include <limits>
@@ -54,28 +55,12 @@ constexpr ssize_t cStringLength(const char* str)
 
 constexpr ssize_t cStringLength(const char8_t* str, size_t maxLength)
 {
-    // Cannot cast str to const char* without breaking constexpr
-    // return cStringLength(reinterpret_cast<const char*>(str), maxLength);
-    if (str == nullptr || maxLength > MAX_C_STRING_LENGTH) {
-        return -1;
-    }
-
-    ssize_t size = 0;
-
-    while (str[size] != 0 && static_cast<size_t>(size) < maxLength) {
-        size++;
-    }
-
-    if (str[size] != 0 && static_cast<size_t>(size) == maxLength) {
-        return static_cast<ssize_t>(maxLength) + 1;
-    }
-
-    return size;
+    return cStringLength(std::bit_cast<const char*>(str), maxLength);
 }
 
 constexpr ssize_t cStringLength(const char8_t* str)
 {
-    return cStringLength(str, MAX_C_STRING_LENGTH);
+    return cStringLength(std::bit_cast<const char*>(str), MAX_C_STRING_LENGTH);
 }
 
 } // namespace fud
diff --git a/include/fud_format.hpp b/include/fud_format.hpp
index 0dff3c1..4536d69 100644
--- a/include/fud_format.hpp
+++ b/include/fud_format.hpp
@@ -1396,8 +1396,7 @@ FormatResult format(Sink& sink, FormatCharMode formatMode, const FormatSpec& for
 template <typename Sink>
 FormatResult format(Sink& sink, FormatCharMode formatMode, const FormatSpec& formatSpec, const utf8* arg)
 {
-    // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
-    return format(sink, formatMode, formatSpec, reinterpret_cast<const char*>(arg));
+    return format(sink, formatMode, formatSpec, std::bit_cast<const char*>(arg));
 }
 
 template <typename Sink>
@@ -1493,8 +1492,7 @@ FormatResult format(Sink& sink, FormatCharMode formatMode, const FormatSpec& for
         return DrainResult{0, FudStatus::FormatInvalid};
     }
     pointerFormatSpec.alternateForm = true;
-    // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
-    return impl::formatIntegral(sink, formatMode, pointerFormatSpec, reinterpret_cast<uintptr_t>(arg));
+    return impl::formatIntegral(sink, formatMode, pointerFormatSpec, std::bit_cast<uintptr_t>(arg));
 }
 
 template <typename Sink>
diff --git a/include/fud_hash.hpp b/include/fud_hash.hpp
index 57b5619..a472171 100644
--- a/include/fud_hash.hpp
+++ b/include/fud_hash.hpp
@@ -57,8 +57,7 @@ struct DefaultHash {
     size_t operator()(const T& value, size_t seed) const
     {
         static_cast<void>(seed);
-        // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
-        return djb2(reinterpret_cast<const utf8*>(&value), sizeof(value));
+        return djb2(std::bit_cast<const utf8*>(&value), sizeof(value));
     }
 };
 
diff --git a/include/fud_hash_map.hpp b/include/fud_hash_map.hpp
index 4333df7..7980bf4 100644
--- a/include/fud_hash_map.hpp
+++ b/include/fud_hash_map.hpp
@@ -156,8 +156,25 @@ class HashMap {
     Option<KeyValuePair> extractPair(const Key& key);
     Option<KeyValuePair> extractPair(Key& key);
 
-    Option<Value> get(const Key& key) const;
-    Option<Value&> getRef(const Key& key);
+    Option<Value> get(const Key& key)
+    {
+        auto hashIndexOption = lookup(key);
+        if (hashIndexOption.isNone()) {
+            return NullOpt;
+        }
+
+        return m_data[hashIndexOption.value()].value().m_value;
+    }
+
+    Option<Value&> getRef(const Key& key) const
+    {
+        auto hashIndexOption = lookup(key);
+        if (hashIndexOption.isNone()) {
+            return NullOpt;
+        }
+
+        return m_data[hashIndexOption.value()].value().m_value;
+    }
 
     Option<const Value&> getConstRef(const Key& key) const
     {
@@ -206,8 +223,7 @@ class HashMap {
             return dataPtrResult.takeError();
         }
 
-        // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
-        auto* dataPtr = reinterpret_cast<Node*>(dataPtrResult.takeOkay());
+        auto* dataPtr = std::bit_cast<Node*>(dataPtrResult.takeOkay());
         for (size_t index = 0; index < count; ++index) {
             const auto* ptr = new (dataPtr + index) Node(NullOpt);
             fudAssert(ptr != nullptr);
@@ -219,8 +235,7 @@ class HashMap {
                 const auto hash = m_hasher(key, m_seed);
                 auto newHashIndexResult = findEmptyBucket(key, count, dataPtr);
                 if (newHashIndexResult.isError()) {
-                    // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
-                    m_allocator->deallocate(reinterpret_cast<std::byte*>(dataPtr), requestedSize);
+                    m_allocator->deallocate(std::bit_cast<std::byte*>(dataPtr), requestedSize);
                     return FudStatus::Failure;
                 }
                 const auto newHashIndex{newHashIndexResult.takeOkay()};
@@ -233,8 +248,7 @@ class HashMap {
 
         auto status = FudStatus::Success;
         if (m_buckets > 0) {
-            // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
-            m_allocator->deallocate(reinterpret_cast<std::byte*>(m_data), m_buckets * NodeSize);
+            m_allocator->deallocate(std::bit_cast<std::byte*>(m_data), m_buckets * NodeSize);
         }
 
         m_data = dataPtr;
@@ -295,8 +309,7 @@ class HashMap {
     {
         auto status = clear();
         if (m_data != nullptr && m_allocator != nullptr) {
-            // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
-            m_allocator->deallocate(reinterpret_cast<std::byte*>(m_data), m_buckets);
+            m_allocator->deallocate(std::bit_cast<std::byte*>(m_data), m_buckets);
         }
 
         m_allocator = nullptr;
diff --git a/include/fud_memory.hpp b/include/fud_memory.hpp
index 6f6816f..bb60ab7 100644
--- a/include/fud_memory.hpp
+++ b/include/fud_memory.hpp
@@ -79,7 +79,7 @@ constexpr void zeroObject(T& object)
     static_assert(std::is_standard_layout_v<T>);
     static_assert(std::is_trivially_copyable_v<T>);
 
-    auto* objPtr = reinterpret_cast<uint8_t*>(&object);
+    auto* objPtr = std::bit_cast<uint8_t*>(&object);
     for (size_t idx = 0; idx < sizeof(object); ++idx) {
         objPtr[idx] = 0;
     }
@@ -95,10 +95,8 @@ void copyMem(T& destination, const U& source)
     static_assert(std::is_trivially_copyable_v<T>);
     static_assert(std::is_trivially_copyable_v<U>);
 
-    // NOLINTBEGIN(cppcoreguidelines-pro-type-reinterpret-cast)
-    auto* destPtr = reinterpret_cast<char*>(&destination);
-    const auto* srcPtr = reinterpret_cast<const char*>(&source);
-    // NOLINTEND(cppcoreguidelines-pro-type-reinterpret-cast)
+    auto* destPtr = std::bit_cast<char*>(&destination);
+    const auto* srcPtr = std::bit_cast<const char*>(&source);
 
     for (size_t idx = 0; idx < Count; ++idx) {
         destPtr[idx] = srcPtr[idx];
@@ -121,9 +119,7 @@ int compareMem(const T& lhs, const U& rhs)
 
     int difference = 0;
     for (size_t idx = 0; idx < Count; ++idx) {
-        // NOLINTBEGIN(cppcoreguidelines-pro-type-reinterpret-cast)
-        difference = reinterpret_cast<const uint8_t*>(&lhs)[idx] - reinterpret_cast<const uint8_t*>(&rhs)[idx];
-        // NOLINTEND(cppcoreguidelines-pro-type-reinterpret-cast)
+        difference = std::bit_cast<const uint8_t*>(&lhs)[idx] - std::bit_cast<const uint8_t*>(&rhs)[idx];
         if (difference != 0) {
             break;
         }
@@ -142,9 +138,7 @@ int compareMem(const T& lhs, U&& rhs)
 
     int difference = 0;
     for (size_t idx = 0; idx < Count; ++idx) {
-        // NOLINTBEGIN(cppcoreguidelines-pro-type-reinterpret-cast)
-        difference = reinterpret_cast<const uint8_t*>(&lhs)[idx] - reinterpret_cast<const uint8_t*>(&uRhs)[idx];
-        // NOLINTEND(cppcoreguidelines-pro-type-reinterpret-cast)
+        difference = std::bit_cast<const uint8_t*>(&lhs)[idx] - std::bit_cast<const uint8_t*>(&uRhs)[idx];
         if (difference != 0) {
             break;
         }
diff --git a/include/fud_option.hpp b/include/fud_option.hpp
index 5a5611f..f2e86ca 100644
--- a/include/fud_option.hpp
+++ b/include/fud_option.hpp
@@ -172,11 +172,9 @@ class Option {
     {
         fudAssert(m_engaged);
         if constexpr (IsRef) {
-            // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
-            return *reinterpret_cast<const std::reference_wrapper<ValueType>*>(m_data.data());
+            return *std::bit_cast<const std::reference_wrapper<ValueType>*>(m_data.data());
         } else {
-            // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
-            return *reinterpret_cast<const ValueType*>(m_data.data());
+            return *std::bit_cast<const ValueType*>(m_data.data());
         }
     }
 
@@ -184,11 +182,9 @@ class Option {
     {
         fudAssert(m_engaged);
         if constexpr (IsRef) {
-            // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
-            return *reinterpret_cast<std::reference_wrapper<ValueType>*>(m_data.data());
+            return *std::bit_cast<std::reference_wrapper<ValueType>*>(m_data.data());
         } else {
-            // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
-            return *reinterpret_cast<ValueType*>(m_data.data());
+            return *std::bit_cast<ValueType*>(m_data.data());
         }
     }
 
@@ -196,8 +192,15 @@ class Option {
     {
         fudAssert(m_engaged);
         static_assert(!IsRef);
-        // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
-        return std::move(*reinterpret_cast<const ValueType*>(m_data.data()));
+        return std::move(*std::bit_cast<const ValueType*>(m_data.data()));
+    }
+
+    [[nodiscard]] ValueType& mutValueOr(ValueType& alternative)
+    {
+        if (m_engaged) {
+            return value();
+        }
+        return alternative;
     }
 
     [[nodiscard]] constexpr const ValueType& valueOr(const ValueType& alternative) const&
@@ -232,10 +235,9 @@ class Option {
     {
         if (m_engaged) {
             if constexpr (IsRef) {
-                // reinterpret_cast<std::reference_wrapper<ValueType>*>(m_data.data());
+                // do nothing
             } else {
-                // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
-                reinterpret_cast<ValueType*>(m_data.data())->~ValueType();
+                std::bit_cast<ValueType*>(m_data.data())->~ValueType();
             }
             cleanup();
         }
diff --git a/include/fud_result.hpp b/include/fud_result.hpp
index 88d0dc4..0394156 100644
--- a/include/fud_result.hpp
+++ b/include/fud_result.hpp
@@ -200,8 +200,7 @@ class [[nodiscard]] Result {
     [[nodiscard]] constexpr const T& getOkay() const&
     {
         fudAssert(isOkay());
-        // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
-        return *reinterpret_cast<const T*>(m_data.data());
+        return *std::bit_cast<const T*>(m_data.data());
     }
 
     [[nodiscard]] constexpr const T& getOkayOr(const T& alternative) const&
@@ -210,15 +209,13 @@ class [[nodiscard]] Result {
             // NOLINTNEXTLINE(bugprone-return-const-ref-from-parameter)
             return alternative;
         }
-        // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
-        return *reinterpret_cast<const T*>(m_data.data());
+        return *std::bit_cast<const T*>(m_data.data());
     }
 
     [[nodiscard]] constexpr const E& getError() const&
     {
         fudAssert(isError());
-        // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
-        return *reinterpret_cast<const E*>(m_data.data());
+        return *std::bit_cast<const E*>(m_data.data());
     }
 
     [[nodiscard]] constexpr const E& getErrorOr(const E& alternative) const&
@@ -227,15 +224,13 @@ class [[nodiscard]] Result {
             // NOLINTNEXTLINE(bugprone-return-const-ref-from-parameter)
             return alternative;
         }
-        // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
-        return *reinterpret_cast<const E*>(m_data.data());
+        return *std::bit_cast<const E*>(m_data.data());
     }
 
     [[nodiscard]] constexpr T&& takeOkay()
     {
         fudAssert(isOkay());
-        // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
-        return std::move(*reinterpret_cast<T*>(m_data.data()));
+        return std::move(*std::bit_cast<T*>(m_data.data()));
     }
 
     [[nodiscard]] constexpr T&& takeOkayOr(T&& alternative)
@@ -243,15 +238,13 @@ class [[nodiscard]] Result {
         if (!isOkay()) {
             return std::move(alternative);
         }
-        // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
-        return std::move(*reinterpret_cast<T*>(m_data.data()));
+        return std::move(*std::bit_cast<T*>(m_data.data()));
     }
 
     [[nodiscard]] constexpr E&& takeError()
     {
         fudAssert(isError());
-        // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
-        return std::move(*reinterpret_cast<E*>(m_data.data()));
+        return std::move(*std::bit_cast<E*>(m_data.data()));
     }
 
     [[nodiscard]] constexpr E&& takeErrorOr(E&& alternative)
@@ -259,8 +252,7 @@ class [[nodiscard]] Result {
         if (!isError()) {
             return std::move(alternative);
         }
-        // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
-        return std::move(*reinterpret_cast<E*>(m_data.data()));
+        return std::move(*std::bit_cast<E*>(m_data.data()));
     }
 
   private:
@@ -307,12 +299,10 @@ class [[nodiscard]] Result {
     constexpr void destroy() noexcept
     {
         if (m_discriminant == Discriminant::Okay) {
-            // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
-            reinterpret_cast<T*>(m_data.data())->~T();
+            std::bit_cast<T*>(m_data.data())->~T();
             m_discriminant = Discriminant::Invalid;
         } else if (m_discriminant == Discriminant::Error) {
-            // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
-            reinterpret_cast<E*>(m_data.data())->~E();
+            std::bit_cast<E*>(m_data.data())->~E();
             m_discriminant = Discriminant::Invalid;
         }
     }
diff --git a/include/fud_string.hpp b/include/fud_string.hpp
index 1c189c2..2c2173b 100644
--- a/include/fud_string.hpp
+++ b/include/fud_string.hpp
@@ -133,8 +133,7 @@ class String {
             if constexpr (std::is_same_v<decltype(cStringItem), const char*>) {
                 cString = cStringItem;
             } else if constexpr (std::is_same_v<decltype(cStringItem), const utf8*>) {
-                // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
-                cString = reinterpret_cast<const char*>(cStringItem);
+                cString = std::bit_cast<const char*>(cStringItem);
             } else {
                 static_assert(!std::is_same_v<decltype(cStringItem), const char*>);
             }
@@ -275,8 +274,7 @@ class String {
     /** \brief The underlying data as an explicit c string. */
     [[nodiscard]] const char* c_str() const
     {
-        // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
-        return reinterpret_cast<const char*>(data());
+        return std::bit_cast<const char*>(data());
     }
 
     [[nodiscard]] StringView asView() const
diff --git a/include/fud_string_view.hpp b/include/fud_string_view.hpp
index f71919d..e3ff4d7 100644
--- a/include/fud_string_view.hpp
+++ b/include/fud_string_view.hpp
@@ -56,16 +56,14 @@ struct StringView {
     // NOLINTNEXTLINE(cppcoreguidelines-avoid-c-arrays)
     StringView(const char (&input)[N]) :
         m_length{N - 1},
-        // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
-        m_data{reinterpret_cast<const utf8*>(input)}
+        m_data{std::bit_cast<const utf8*>(&input[0])}
     {
         static_assert(N > 0);
     }
 
     StringView(size_t strLen, const char* strData) :
         m_length(strLen),
-        // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
-        m_data{reinterpret_cast<const utf8*>(strData)}
+        m_data{std::bit_cast<const utf8*>(&strData[0])}
     {
     }
 
@@ -80,13 +78,11 @@ struct StringView {
     constexpr static StringView makeFromCString(const char (&input)[N])
     {
         static_assert(N > 0);
-        // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
-        return StringView{N - 1, reinterpret_cast<const utf8*>(input)};
+        return StringView{N - 1, std::bit_cast<const utf8*>(&input[0])};
     }
 
-    [[nodiscard]] std::string_view as_string_view() const {
-        // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
-        return std::string_view{reinterpret_cast<const char*>(m_data), m_length};
+    [[nodiscard]] constexpr std::string_view as_string_view() const {
+        return std::string_view{std::bit_cast<const char*>(m_data), m_length};
     }
 
     [[nodiscard]] constexpr Span<const utf8> asSpan() const
@@ -106,8 +102,7 @@ struct StringView {
 
     [[nodiscard]] const char* c_str() const
     {
-        // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
-        return reinterpret_cast<const char*>(m_data);
+        return std::bit_cast<const char*>(m_data);
     }
 
     constexpr const utf8& operator[](size_t index) const
diff --git a/include/fud_vector.hpp b/include/fud_vector.hpp
index 9808a7d..1ba2abf 100644
--- a/include/fud_vector.hpp
+++ b/include/fud_vector.hpp
@@ -124,8 +124,7 @@ class Vector {
         }
 
         output.m_allocator = allocator;
-        // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
-        output.m_data = reinterpret_cast<T*>(dataPtrResult.getOkay());
+        output.m_data = std::bit_cast<T*>(dataPtrResult.getOkay());
         output.m_length = 0;
         output.m_capacity = capacity;
         return FudStatus::Success;
@@ -365,8 +364,7 @@ class Vector {
             return dataPtrResult.takeError();
         }
 
-        // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
-        auto* dataPtr = reinterpret_cast<T*>(dataPtrResult.takeOkay());
+        auto* dataPtr = std::bit_cast<T*>(dataPtrResult.takeOkay());
         for (size_t index = 0; index < m_length; ++index) {
             const auto* ptr = new (dataPtr + index) T(std::move(m_data[index]));
             fudAssert(ptr != nullptr);
@@ -375,8 +373,7 @@ class Vector {
 
         auto status = FudStatus::Success;
         if (m_capacity > 0) {
-            // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
-            m_allocator->deallocate(reinterpret_cast<std::byte*>(m_data), m_capacity * ElementSize);
+            m_allocator->deallocate(std::bit_cast<std::byte*>(m_data), m_capacity * ElementSize);
         }
 
         m_data = dataPtr;
@@ -748,8 +745,7 @@ class Vector {
         auto status = clear();
 
         if (m_data != nullptr && m_allocator != nullptr) {
-            // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
-            m_allocator->deallocate(reinterpret_cast<std::byte*>(m_data), m_capacity * ElementSize);
+            m_allocator->deallocate(std::bit_cast<std::byte*>(m_data), m_capacity * ElementSize);
         }
 
         m_allocator = nullptr;