implemented roller naive hash

roller.hpp

+// roller.hpp
+// Copyright (C) 2022 MicroNeil Research Corporation.
+//
+// This software is released under the MIT license. See LICENSE.TXT.
+//
+// Roller is a naive rolling hash system for rapid string searches.
+// Roller32 accommodates matches up to 4 bytes.
+// Roller64 accommodates matches up to 8 bytes.
+
+#pragma once
+
+#include <cstdint>
+#include <string>
+#include <vector>
+
+namespace codedweller {
+
+    class Roller32 {
+        private:
+            uint_fast32_t roller;
+
+        public:
+            Roller32() : roller(0) {}
+            uint_fast32_t value() const { return roller; }
+            uint_fast32_t add(uint8_t byte) { 
+                roller = roller << 8 | byte;
+                return roller;
+            }
+    };
+
+    class Roller64 {
+        private:
+            uint_fast64_t roller;
+
+        public:
+            Roller64() : roller(0) {}
+            uint_fast64_t value() const { return roller; }
+            uint_fast64_t add(uint8_t byte) {
+                roller = roller << 8 | byte;
+                return roller;
+            }
+    };
+
+    class RollerMatch32 {
+        private:
+            uint_fast32_t match;
+            uint_fast32_t mask;
+
+        public:
+            RollerMatch32(const std::vector<unsigned char> pattern) {
+                match = mask = 0;
+                size_t ingest = std::min(sizeof(uint_fast32_t), pattern.size());
+                Roller32 matcher;
+                Roller32 masker;
+                for(size_t count = 0; count < ingest; count++) { 
+                    matcher.add(pattern.at(count));
+                    masker.add(0xFF);
+                }
+                match = matcher.value();
+                mask = masker.value();
+            }
+
+            RollerMatch32(const std::string pattern) {
+                match = mask = 0;
+                size_t ingest = std::min(sizeof(uint_fast32_t), pattern.size());
+                Roller32 matcher;
+                Roller32 masker;
+                for(size_t count = 0; count < ingest; count++) { 
+                    matcher.add(pattern.at(count));
+                    masker.add(0xFF);
+                }
+                match = matcher.value();
+                mask = masker.value();
+            }
+
+            bool matches(const Roller32 roller) {
+                return (match == (roller.value() & mask));
+            }
+
+    };
+
+    class RollerMatch64 {
+        private:
+            uint_fast64_t match;
+            uint_fast64_t mask;
+
+        public:
+            RollerMatch64(const std::vector<unsigned char> pattern) {
+                match = mask = 0;
+                size_t ingest = std::min(sizeof(uint_fast64_t), pattern.size());
+                Roller64 matcher;
+                Roller64 masker;
+                for(size_t count = 0; count < ingest; count++) { 
+                    matcher.add(pattern.at(count));
+                    masker.add(0xFF);
+                }
+                match = matcher.value();
+                mask = masker.value();
+            }
+
+            RollerMatch64(const std::string pattern) {
+                match = mask = 0;
+                size_t ingest = std::min(sizeof(uint_fast64_t), pattern.size());
+                Roller64 matcher;
+                Roller64 masker;
+                for(size_t count = 0; count < ingest; count++) { 
+                    matcher.add(pattern.at(count));
+                    masker.add(0xFF);
+                }
+                match = matcher.value();
+                mask = masker.value();
+            }
+
+            bool matches(const Roller64 roller) {
+                return (match == (roller.value() & mask));
+            }
+    };
+
+
+}
+
+