From cb9fa588ba8144fcdd52ba4b83d69d93fb18066f Mon Sep 17 00:00:00 2001
From: Dominick Allen <djallen@librehumanitas.org>
Date: Sun, 30 Mar 2025 23:08:43 -0500
Subject: Add hash map.

---
 include/fud_result.hpp | 21 +++++++++++++++++----
 1 file changed, 17 insertions(+), 4 deletions(-)

(limited to 'include/fud_result.hpp')

diff --git a/include/fud_result.hpp b/include/fud_result.hpp
index 0f501e8..88d0dc4 100644
--- a/include/fud_result.hpp
+++ b/include/fud_result.hpp
@@ -60,7 +60,7 @@ class [[nodiscard]] Result {
 
     constexpr Result(Okay<T>&& value) : m_data{}, m_discriminant{Discriminant::Okay}
     {
-        auto ptrValue = new (m_data.data()) T(std::move(value.value));
+        auto ptrValue = new (m_data.data()) T(std::move(value).value);
         fudAssert(ptrValue != nullptr);
     }
 
@@ -72,7 +72,7 @@ class [[nodiscard]] Result {
 
     constexpr Result(E&& value) : m_data{}, m_discriminant{Discriminant::Error}
     {
-        auto ptrValue = new (m_data.data()) E(std::move(value.value));
+        auto ptrValue = new (m_data.data()) E(std::move(value).value);
         fudAssert(ptrValue != nullptr);
     }
 
@@ -170,7 +170,7 @@ class [[nodiscard]] Result {
     template <typename F>
     static constexpr ResultType okay(Result<T, F>&& okayRes)
     {
-        return ResultType::okay(okayRes.takeOkay());
+        return ResultType::okay(std::move(okayRes).takeOkay());
     }
 
     template <typename U>
@@ -182,7 +182,7 @@ class [[nodiscard]] Result {
     template <typename U>
     static constexpr ResultType error(Result<U, E>&& errorRes)
     {
-        return ResultType::error(errorRes.takeError());
+        return ResultType::error(std::move(errorRes).takeError());
     }
 
     [[nodiscard]] constexpr bool isOkay() const
@@ -200,34 +200,41 @@ 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());
     }
 
     [[nodiscard]] constexpr const T& getOkayOr(const T& alternative) const&
     {
         if (!isOkay()) {
+            // NOLINTNEXTLINE(bugprone-return-const-ref-from-parameter)
             return alternative;
         }
+        // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
         return *reinterpret_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());
     }
 
     [[nodiscard]] constexpr const E& getErrorOr(const E& alternative) const&
     {
         if (!isError()) {
+            // NOLINTNEXTLINE(bugprone-return-const-ref-from-parameter)
             return alternative;
         }
+        // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
         return *reinterpret_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()));
     }
 
@@ -236,12 +243,14 @@ class [[nodiscard]] Result {
         if (!isOkay()) {
             return std::move(alternative);
         }
+        // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
         return std::move(*reinterpret_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()));
     }
 
@@ -250,6 +259,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()));
     }
 
@@ -297,9 +307,11 @@ 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();
             m_discriminant = Discriminant::Invalid;
         } else if (m_discriminant == Discriminant::Error) {
+            // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
             reinterpret_cast<E*>(m_data.data())->~E();
             m_discriminant = Discriminant::Invalid;
         }
@@ -317,6 +329,7 @@ class [[nodiscard]] Result {
     } m_discriminant{Discriminant::Invalid};
 };
 
+// NOLINTNEXTLINE(cppcoreguidelines-macro-usage)
 #define M_TakeOrReturn(HYGIENE_RESULT_TYPE, HYGIENE_EXPRESSION)            \
     ({                                                                     \
         auto HYGIENE_RESULT{(HYGIENE_EXPRESSION)};                         \
-- 
cgit v1.2.3