Add FNV-1 and FNV-1a hash implementations with corresponding tests

CMakeLists.txt

@@ -14,6 +14,8 @@ add_library(
         INTERFACE
         include/hash23/hash23.h
         include/hash23/sha2_512.h
+        include/hash23/fnv_1.h
+        include/hash23/fnv_1a.h
 )
 add_library(hash23::hash23 ALIAS hash23)
 

include/hash23/fnv_1.h

@@ -0,0 +1,66 @@
+//
+// Created by Rene Windegger on 22/03/2026.
+//
+
+#pragma once
+
+#include <span>
+#include <vector>
+
+namespace hash23 {
+    class fnv_1 {
+    private:
+        std::vector<std::uint8_t> buffer_;
+
+        [[nodiscard]] static consteval std::size_t prime() {
+            if constexpr (sizeof(std::size_t) == 4) {
+                return 0x01000193uz;
+            } else {
+                return 0x00000100000001b3uz;
+            }
+            return 0uz;
+        }
+
+        [[nodiscard]] static consteval std::size_t offset_basis() {
+            if constexpr (sizeof(std::size_t) == 4) {
+                return 0x811c9dc5uz;
+            } else {
+                return 0xcbf29ce484222325uz;
+            }
+            return 0uz;
+        }
+
+        template<typename T>
+            requires std::ranges::contiguous_range<T>
+        constexpr void update(T const &data) {
+            auto const start_offset = buffer_.size();
+            buffer_.resize(start_offset + data.size());
+            std::copy_n(data.data(), data.size(), buffer_.data() + start_offset);
+        }
+
+        [[nodiscard]] constexpr std::size_t finalize() const {
+            std::size_t hash = offset_basis();
+
+            for (auto const &byte : buffer_) {
+                hash *= prime();
+                hash ^= byte;
+            }
+
+            return hash;
+        }
+    public:
+        template<typename T>
+            requires std::ranges::contiguous_range<T>
+        [[nodiscard]] static constexpr std::size_t calculate(T const &data) {
+            fnv_1 r;
+            r.update(data);
+            return r.finalize();
+        }
+
+        template<std::size_t N>
+        [[nodiscard]] static constexpr std::size_t calculate(char const (&str)[N]) {
+            auto const block = std::span(str, N - 1);
+            return calculate(block);
+        }
+    };
+}

include/hash23/fnv_1a.h

@@ -0,0 +1,66 @@
+//
+// Created by Rene Windegger on 22/03/2026.
+//
+
+#pragma once
+
+#include <span>
+#include <vector>
+
+namespace hash23 {
+    class fnv_1a {
+    private:
+        std::vector<std::uint8_t> buffer_;
+
+        [[nodiscard]] static consteval std::size_t prime() {
+            if constexpr (sizeof(std::size_t) == 4) {
+                return 0x01000193uz;
+            } else {
+                return 0x00000100000001b3uz;
+            }
+            return 0uz;
+        }
+
+        [[nodiscard]] static consteval std::size_t offset_basis() {
+            if constexpr (sizeof(std::size_t) == 4) {
+                return 0x811c9dc5uz;
+            } else {
+                return 0xcbf29ce484222325uz;
+            }
+            return 0uz;
+        }
+
+        template<typename T>
+            requires std::ranges::contiguous_range<T>
+        constexpr void update(T const &data) {
+            auto const start_offset = buffer_.size();
+            buffer_.resize(start_offset + data.size());
+            std::copy_n(data.data(), data.size(), buffer_.data() + start_offset);
+        }
+
+        [[nodiscard]] constexpr std::size_t finalize() const {
+            std::size_t hash = offset_basis();
+
+            for (auto const &byte : buffer_) {
+                hash ^= byte;
+                hash *= prime();
+            }
+
+            return hash;
+        }
+    public:
+        template<typename T>
+            requires std::ranges::contiguous_range<T>
+        [[nodiscard]] static constexpr std::size_t calculate(T const &data) {
+            fnv_1a r;
+            r.update(data);
+            return r.finalize();
+        }
+
+        template<std::size_t N>
+        [[nodiscard]] static constexpr std::size_t calculate(char const (&str)[N]) {
+            auto const block = std::span(str, N - 1);
+            return calculate(block);
+        }
+    };
+}

include/hash23/hash23.h

@@ -4,4 +4,6 @@
 
 #pragma once
 
+#include <hash23/fnv_1.h>
+#include <hash23/fnv_1a.h>
 #include <hash23/sha2_512.h>

tests/CMakeLists.txt

@@ -8,6 +8,8 @@ add_executable(
         hash23_tests
         main.cpp
         sha2_512_tests.cpp
+        fnv_1_tests.cpp
+        fnv_1a_tests.cpp
 )
 
 if(MSVC)

tests/fnv_1_tests.cpp

@@ -0,0 +1,14 @@
+//
+// Created by Rene Windegger on 22/03/2026.
+//
+
+#include <gtest/gtest.h>
+#include <hash23/hash23.h>
+
+namespace {
+    TEST(fnv_1, single_block_test) {
+        auto const actual = hash23::fnv_1::calculate("Hello, World!");
+        constexpr std::size_t expected = 0x7b5ea4c513c14886uz;
+        EXPECT_EQ(expected, actual);
+    }
+}

tests/fnv_1a_tests.cpp

@@ -0,0 +1,14 @@
+//
+// Created by Rene Windegger on 22/03/2026.
+//
+
+#include <gtest/gtest.h>
+#include <hash23/hash23.h>
+
+namespace {
+    TEST(fnv_1a, single_block_test) {
+        auto const actual = hash23::fnv_1a::calculate("Hello, World!");
+        constexpr std::size_t expected = 0x6ef05bd7cc857c54uz;
+        EXPECT_EQ(expected, actual);
+    }
+}