refactor: unroll hash value

LiteLDev · May 31, 2024 · 6de9ecf · 6de9ecf
1 parent b99e41f
commit 6de9ecf
Show file tree

Hide file tree

Showing 3 changed files with 16 additions and 47 deletions.
diff --git a/src/ll/api/utils/HashUtils.h b/src/ll/api/utils/HashUtils.h
@@ -4,6 +4,7 @@
 #include <type_traits>
 #include <vector>
 
+#include "ll/api/base/Meta.h"
 #include "ll/api/base/StdInt.h"
 
 namespace ll::inline utils::hash_utils {
@@ -26,7 +27,7 @@ constexpr void hashCombine(T const& v, size_t& seed) {
     uint64           hash  = 0xcbf29ce484222325;
     constexpr uint64 prime = 0x100000001b3;
     for (char c : x) {
-        hash  = hash ^ c;
+        hash ^= c;
         hash *= prime;
     }
     return hash;
@@ -43,7 +44,13 @@ constexpr void hashCombine(T const& v, size_t& seed) {
 template <class T>
     requires(std::is_trivially_destructible_v<T>)
 [[nodiscard]] constexpr uint64 rawHashType(T const& v) {
-    return doHash2({reinterpret_cast<char const*>(std::addressof(v)), sizeof(T)});
+    uint64           hash  = 0xcbf29ce484222325;
+    constexpr uint64 prime = 0x100000001b3;
+    meta::unroll<sizeof(T)>([&](size_t i) {
+        hash ^= reinterpret_cast<char const*>(std::addressof(v))[i];
+        hash *= prime;
+    });
+    return hash;
 }
 
 template <class T>

diff --git a/src/mc/math/vector/base/VectorBase.h b/src/mc/math/vector/base/VectorBase.h
@@ -62,7 +62,7 @@ struct LL_EBO VectorBase : concepts::VectorBaseTag {
     [[nodiscard]] constexpr std::string toString() const noexcept {
         std::string res("(");
         forEachComponent([&]<typename axis_type>(size_t iter) constexpr {
-            res  = std::move(std::format("{}{}", res, static_cast<T const*>(this)->template get<axis_type>(iter)));
+            res  = std::format("{}{}", res, static_cast<T const*>(this)->template get<axis_type>(iter));
             res += ((iter < size() - 1) ? ", " : ")");
         });
         return res;

diff --git a/src/mc/math/vector/impl/VecImpl.h b/src/mc/math/vector/impl/VecImpl.h
@@ -57,17 +57,11 @@
         }                                                                                                              \
         template <typename T>                                                                                          \
         [[nodiscard]] constexpr T& get(size_t index) noexcept {                                                        \
-            if (index == 1) {                                                                                          \
-                return (T&)z;                                                                                          \
-            }                                                                                                          \
-            return (T&)x;                                                                                              \
+            return (T&)((&x)[index]);                                                                                  \
         }                                                                                                              \
         template <typename T>                                                                                          \
         [[nodiscard]] constexpr T get(size_t index) const noexcept {                                                   \
-            if (index == 1) {                                                                                          \
-                return (T)z;                                                                                           \
-            }                                                                                                          \
-            return (T)x;                                                                                               \
+            return (T&)((&x)[index]);                                                                                  \
         }                                                                                                              \
     }
 
@@ -105,25 +99,11 @@
         }                                                                                                              \
         template <typename T>                                                                                          \
         [[nodiscard]] constexpr T& get(size_t index) noexcept {                                                        \
-            switch (index) {                                                                                           \
-            case 1:                                                                                                    \
-                return (T&)y;                                                                                          \
-            case 2:                                                                                                    \
-                return (T&)z;                                                                                          \
-            default:                                                                                                   \
-                return (T&)x;                                                                                          \
-            }                                                                                                          \
+            return (T&)((&x)[index]);                                                                                  \
         }                                                                                                              \
         template <typename T>                                                                                          \
         [[nodiscard]] constexpr T get(size_t index) const noexcept {                                                   \
-            switch (index) {                                                                                           \
-            case 1:                                                                                                    \
-                return (T)y;                                                                                           \
-            case 2:                                                                                                    \
-                return (T)z;                                                                                           \
-            default:                                                                                                   \
-                return (T)x;                                                                                           \
-            }                                                                                                          \
+            return (T&)((&x)[index]);                                                                                  \
         }                                                                                                              \
     }
 
@@ -167,29 +147,11 @@
         }                                                                                                              \
         template <typename T>                                                                                          \
         [[nodiscard]] constexpr T& get(size_t index) noexcept {                                                        \
-            switch (index) {                                                                                           \
-            case 1:                                                                                                    \
-                return (T&)y;                                                                                          \
-            case 2:                                                                                                    \
-                return (T&)z;                                                                                          \
-            case 3:                                                                                                    \
-                return (T&)w;                                                                                          \
-            default:                                                                                                   \
-                return (T&)x;                                                                                          \
-            }                                                                                                          \
+            return (T&)((&x)[index]);                                                                                  \
         }                                                                                                              \
         template <typename T>                                                                                          \
         [[nodiscard]] constexpr T get(size_t index) const noexcept {                                                   \
-            switch (index) {                                                                                           \
-            case 1:                                                                                                    \
-                return (T)y;                                                                                           \
-            case 2:                                                                                                    \
-                return (T)z;                                                                                           \
-            case 3:                                                                                                    \
-                return (T)w;                                                                                           \
-            default:                                                                                                   \
-                return (T)x;                                                                                           \
-            }                                                                                                          \
+            return (T&)((&x)[index]);                                                                                  \
         }                                                                                                              \
     }