From 544fa313c153f880a25814012f1ba534b5473f2d Mon Sep 17 00:00:00 2001
From: Orange <orange-cpp@yandex.ru>
Date: Sat, 4 Oct 2025 18:30:43 +0300
Subject: [PATCH 1/7] Adds pattern scanning functionality

Implements a pattern scanner for byte sequence parsing.

Introduces `omath::PatternScanner` to parse pattern strings, which represent byte sequences.
Adds support for wildcard characters ('?' and '?') to represent optional bytes in the pattern.
Includes unit tests for basic read operations to ensure proper functionality.
---
 .idea/editor.xml                         |  4 +-
 include/omath/utility/pattern_scan.hpp   | 28 +++++++++++++
 source/utility/pattern_scan.cpp          | 51 ++++++++++++++++++++++++
 tests/general/unit_test_pattern_scan.cpp | 11 +++++
 4 files changed, 92 insertions(+), 2 deletions(-)
 create mode 100644 include/omath/utility/pattern_scan.hpp
 create mode 100644 source/utility/pattern_scan.cpp
 create mode 100644 tests/general/unit_test_pattern_scan.cpp

diff --git a/.idea/editor.xml b/.idea/editor.xml
index fde5348..373c50f 100644
--- a/.idea/editor.xml
+++ b/.idea/editor.xml
@@ -201,7 +201,7 @@
     <option name="/Default/CodeInspection/Highlighting/InspectionSeverities/=CppStaticDataMemberInUnnamedStruct/@EntryIndexedValue" value="WARNING" type="string" />
     <option name="/Default/CodeInspection/Highlighting/InspectionSeverities/=CppStaticSpecifierOnAnonymousNamespaceMember/@EntryIndexedValue" value="SUGGESTION" type="string" />
     <option name="/Default/CodeInspection/Highlighting/InspectionSeverities/=CppStringLiteralToCharPointerConversion/@EntryIndexedValue" value="WARNING" type="string" />
-    <option name="/Default/CodeInspection/Highlighting/InspectionSeverities/=CppTabsAreDisallowed/@EntryIndexedValue" value="WARNING" type="string" />
+    <option name="/Default/CodeInspection/Highlighting/InspectionSeverities/=CppTabsAreDisallowed/@EntryIndexedValue" value="DO_NOT_SHOW" type="string" />
     <option name="/Default/CodeInspection/Highlighting/InspectionSeverities/=CppTemplateArgumentsCanBeDeduced/@EntryIndexedValue" value="HINT" type="string" />
     <option name="/Default/CodeInspection/Highlighting/InspectionSeverities/=CppTemplateParameterNeverUsed/@EntryIndexedValue" value="HINT" type="string" />
     <option name="/Default/CodeInspection/Highlighting/InspectionSeverities/=CppTemplateParameterShadowing/@EntryIndexedValue" value="WARNING" type="string" />
@@ -215,7 +215,7 @@
     <option name="/Default/CodeInspection/Highlighting/InspectionSeverities/=CppUnmatchedPragmaEndRegionDirective/@EntryIndexedValue" value="WARNING" type="string" />
     <option name="/Default/CodeInspection/Highlighting/InspectionSeverities/=CppUnmatchedPragmaRegionDirective/@EntryIndexedValue" value="WARNING" type="string" />
     <option name="/Default/CodeInspection/Highlighting/InspectionSeverities/=CppUnnamedNamespaceInHeaderFile/@EntryIndexedValue" value="WARNING" type="string" />
-    <option name="/Default/CodeInspection/Highlighting/InspectionSeverities/=CppUnnecessaryWhitespace/@EntryIndexedValue" value="WARNING" type="string" />
+    <option name="/Default/CodeInspection/Highlighting/InspectionSeverities/=CppUnnecessaryWhitespace/@EntryIndexedValue" value="DO_NOT_SHOW" type="string" />
     <option name="/Default/CodeInspection/Highlighting/InspectionSeverities/=CppUnsignedZeroComparison/@EntryIndexedValue" value="WARNING" type="string" />
     <option name="/Default/CodeInspection/Highlighting/InspectionSeverities/=CppUnusedIncludeDirective/@EntryIndexedValue" value="WARNING" type="string" />
     <option name="/Default/CodeInspection/Highlighting/InspectionSeverities/=CppUseAlgorithmWithCount/@EntryIndexedValue" value="SUGGESTION" type="string" />
diff --git a/include/omath/utility/pattern_scan.hpp b/include/omath/utility/pattern_scan.hpp
new file mode 100644
index 0000000..f524549
--- /dev/null
+++ b/include/omath/utility/pattern_scan.hpp
@@ -0,0 +1,28 @@
+//
+// Created by Vlad on 10/4/2025.
+//
+
+#pragma once
+#include <expected>
+#include <optional>
+#include <string_view>
+#include <vector>
+
+// ReSharper disable once CppInconsistentNaming
+class unit_test_pattern_scan_read_test_Test;
+namespace omath
+{
+    enum class PatternScanError
+    {
+        INVALID_PATTERN_STRING
+    };
+    class PatternScanner
+    {
+        friend unit_test_pattern_scan_read_test_Test;
+    public:
+    private:
+        [[nodiscard]]
+        static std::expected<std::vector<std::optional<std::byte>>, PatternScanError>
+        parse_pattern(const std::string_view& pattern_string);
+    };
+} // namespace omath
\ No newline at end of file
diff --git a/source/utility/pattern_scan.cpp b/source/utility/pattern_scan.cpp
new file mode 100644
index 0000000..7c6b4d9
--- /dev/null
+++ b/source/utility/pattern_scan.cpp
@@ -0,0 +1,51 @@
+//
+// Created by Vlad on 10/4/2025.
+//
+#include "omath/utility/pattern_scan.hpp"
+#include <charconv>
+
+namespace omath
+{
+
+    std::expected<std::vector<std::optional<std::byte>>, PatternScanError>
+    PatternScanner::parse_pattern(const std::string_view& pattern_string)
+    {
+        std::vector<std::optional<std::byte>> pattern;
+
+        auto start = pattern_string.cbegin();
+
+        while (start != pattern_string.cend())
+        {
+            const auto end = std::find(start, pattern_string.cend(), ' ');
+
+            const auto sting_view_start = std::distance(pattern_string.cbegin(), start);
+            const auto sting_view_end = std::distance(start, end);
+
+            const std::string_view byte_str = pattern_string.substr(sting_view_start, sting_view_end);
+
+            if (byte_str.empty())
+                continue;
+
+            if (byte_str == "?" || byte_str == "??")
+            {
+                pattern.emplace_back(std::nullopt);
+
+                start = end != pattern_string.end() ? std::next(end) : end;
+                continue;
+            }
+
+            std::uint8_t value = 0;
+            // ReSharper disable once CppTooWideScopeInitStatement
+            const auto [_, error_code] = std::from_chars(byte_str.data(), byte_str.data()+byte_str.size(), value, 16);
+
+            if (error_code != std::errc{})
+                return std::unexpected(PatternScanError::INVALID_PATTERN_STRING);
+
+            pattern.emplace_back(static_cast<std::byte>(value));
+
+
+            start = end != pattern_string.end() ? std::next(end) : end;
+        }
+        return pattern;
+    }
+} // namespace omath
\ No newline at end of file
diff --git a/tests/general/unit_test_pattern_scan.cpp b/tests/general/unit_test_pattern_scan.cpp
new file mode 100644
index 0000000..0233495
--- /dev/null
+++ b/tests/general/unit_test_pattern_scan.cpp
@@ -0,0 +1,11 @@
+//
+// Created by Vlad on 10/4/2025.
+//
+#include "gtest/gtest.h"
+#include <omath/utility/pattern_scan.hpp>
+#include <source_location>
+
+TEST(unit_test_pattern_scan, read_test)
+{
+    std::ignore = omath::PatternScanner::parse_pattern("FF ? ?? E9");
+}
\ No newline at end of file

From 6319aa81ab9326210052439e26a08b4864b6609b Mon Sep 17 00:00:00 2001
From: Orange <orange-cpp@yandex.ru>
Date: Sat, 4 Oct 2025 18:33:57 +0300
Subject: [PATCH 2/7] Handles empty pattern strings

Skips processing when encountering an empty string slice during pattern scanning.
This prevents unexpected behavior and potential errors when the pattern string contains sections that result in an empty byte string.
---
 source/utility/pattern_scan.cpp | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/source/utility/pattern_scan.cpp b/source/utility/pattern_scan.cpp
index 7c6b4d9..3efd097 100644
--- a/source/utility/pattern_scan.cpp
+++ b/source/utility/pattern_scan.cpp
@@ -24,8 +24,10 @@ namespace omath
             const std::string_view byte_str = pattern_string.substr(sting_view_start, sting_view_end);
 
             if (byte_str.empty())
+            {
+                start = end != pattern_string.end() ? std::next(end) : end;
                 continue;
-
+            }
             if (byte_str == "?" || byte_str == "??")
             {
                 pattern.emplace_back(std::nullopt);

From 64e6ba363264db7c7d27579c6c767947b24bf7a5 Mon Sep 17 00:00:00 2001
From: Orange <orange-cpp@yandex.ru>
Date: Sat, 4 Oct 2025 18:43:05 +0300
Subject: [PATCH 3/7] Adds corner case tests for pattern scanning

Adds new test cases to cover additional scenarios for pattern scanning, including tests for leading/trailing whitespace and spacing variations to ensure robustness.
---
 include/omath/utility/pattern_scan.hpp   |  6 ++++
 source/utility/pattern_scan.cpp          |  1 +
 tests/general/unit_test_pattern_scan.cpp | 38 +++++++++++++++++++++++-
 3 files changed, 44 insertions(+), 1 deletion(-)

diff --git a/include/omath/utility/pattern_scan.hpp b/include/omath/utility/pattern_scan.hpp
index f524549..3f5ce6d 100644
--- a/include/omath/utility/pattern_scan.hpp
+++ b/include/omath/utility/pattern_scan.hpp
@@ -10,6 +10,9 @@
 
 // ReSharper disable once CppInconsistentNaming
 class unit_test_pattern_scan_read_test_Test;
+class unit_test_pattern_scan_corner_case_1_Test;
+class unit_test_pattern_scan_corner_case_2_Test;
+class unit_test_pattern_scan_corner_case_3_Test;
 namespace omath
 {
     enum class PatternScanError
@@ -19,6 +22,9 @@ namespace omath
     class PatternScanner
     {
         friend unit_test_pattern_scan_read_test_Test;
+        friend unit_test_pattern_scan_corner_case_1_Test;
+        friend unit_test_pattern_scan_corner_case_2_Test;
+        friend unit_test_pattern_scan_corner_case_3_Test;
     public:
     private:
         [[nodiscard]]
diff --git a/source/utility/pattern_scan.cpp b/source/utility/pattern_scan.cpp
index 3efd097..b2ae08e 100644
--- a/source/utility/pattern_scan.cpp
+++ b/source/utility/pattern_scan.cpp
@@ -28,6 +28,7 @@ namespace omath
                 start = end != pattern_string.end() ? std::next(end) : end;
                 continue;
             }
+
             if (byte_str == "?" || byte_str == "??")
             {
                 pattern.emplace_back(std::nullopt);
diff --git a/tests/general/unit_test_pattern_scan.cpp b/tests/general/unit_test_pattern_scan.cpp
index 0233495..9b03486 100644
--- a/tests/general/unit_test_pattern_scan.cpp
+++ b/tests/general/unit_test_pattern_scan.cpp
@@ -5,7 +5,43 @@
 #include <omath/utility/pattern_scan.hpp>
 #include <source_location>
 
+
 TEST(unit_test_pattern_scan, read_test)
 {
-    std::ignore = omath::PatternScanner::parse_pattern("FF ? ?? E9");
+    const auto result = omath::PatternScanner::parse_pattern("FF ? ?? E9");
+
+    EXPECT_EQ(result->at(0), static_cast<std::byte>(0xFF));
+    EXPECT_EQ(result->at(1), std::nullopt);
+    EXPECT_EQ(result->at(2), std::nullopt);
+    EXPECT_EQ(result->at(3), static_cast<std::byte>(0xE9));
+}
+
+TEST(unit_test_pattern_scan, corner_case_1)
+{
+    const auto result = omath::PatternScanner::parse_pattern("     FF ? ?? E9");
+
+    EXPECT_EQ(result->at(0), static_cast<std::byte>(0xFF));
+    EXPECT_EQ(result->at(1), std::nullopt);
+    EXPECT_EQ(result->at(2), std::nullopt);
+    EXPECT_EQ(result->at(3), static_cast<std::byte>(0xE9));
+}
+
+TEST(unit_test_pattern_scan, corner_case_2)
+{
+    const auto result = omath::PatternScanner::parse_pattern("     FF ? ?? E9       ");
+
+    EXPECT_EQ(result->at(0), static_cast<std::byte>(0xFF));
+    EXPECT_EQ(result->at(1), std::nullopt);
+    EXPECT_EQ(result->at(2), std::nullopt);
+    EXPECT_EQ(result->at(3), static_cast<std::byte>(0xE9));
+}
+
+TEST(unit_test_pattern_scan, corner_case_3)
+{
+    const auto result = omath::PatternScanner::parse_pattern("     FF ?       ??      E9       ");
+
+    EXPECT_EQ(result->at(0), static_cast<std::byte>(0xFF));
+    EXPECT_EQ(result->at(1), std::nullopt);
+    EXPECT_EQ(result->at(2), std::nullopt);
+    EXPECT_EQ(result->at(3), static_cast<std::byte>(0xE9));
 }
\ No newline at end of file

From 932b0d8debc4d3e6a4de1b95c9b84e7b907f5f8f Mon Sep 17 00:00:00 2001
From: Orange <orange-cpp@yandex.ru>
Date: Sun, 5 Oct 2025 06:37:20 +0300
Subject: [PATCH 4/7] Adds pattern scanning functionality and corner case tests

Implements a pattern scanning feature that allows searching for byte patterns within a byte range.

Adds `scan_for_pattern` method to `PatternScanner` to locate a pattern within a byte span.

Adds corner case tests to verify functionality and handle invalid inputs.
---
 include/omath/utility/pattern_scan.hpp   | 12 ++++++++++
 source/utility/pattern_scan.cpp          | 30 ++++++++++++++++++++++--
 tests/general/unit_test_pattern_scan.cpp |  7 ++++++
 3 files changed, 47 insertions(+), 2 deletions(-)

diff --git a/include/omath/utility/pattern_scan.hpp b/include/omath/utility/pattern_scan.hpp
index 3f5ce6d..c24e778 100644
--- a/include/omath/utility/pattern_scan.hpp
+++ b/include/omath/utility/pattern_scan.hpp
@@ -7,12 +7,20 @@
 #include <optional>
 #include <string_view>
 #include <vector>
+#include <span>
 
 // ReSharper disable once CppInconsistentNaming
 class unit_test_pattern_scan_read_test_Test;
+// ReSharper disable once CppInconsistentNaming
 class unit_test_pattern_scan_corner_case_1_Test;
+// ReSharper disable once CppInconsistentNaming
 class unit_test_pattern_scan_corner_case_2_Test;
+// ReSharper disable once CppInconsistentNaming
 class unit_test_pattern_scan_corner_case_3_Test;
+// ReSharper disable once CppInconsistentNaming
+class unit_test_pattern_scan_corner_case_4_Test;
+
+
 namespace omath
 {
     enum class PatternScanError
@@ -25,7 +33,11 @@ namespace omath
         friend unit_test_pattern_scan_corner_case_1_Test;
         friend unit_test_pattern_scan_corner_case_2_Test;
         friend unit_test_pattern_scan_corner_case_3_Test;
+        friend unit_test_pattern_scan_corner_case_4_Test;
     public:
+        [[nodiscard]]
+        static std::optional<std::span<std::byte>::const_iterator>
+        scan_for_pattern(const std::string_view& pattern, const std::span<std::byte>& range);
     private:
         [[nodiscard]]
         static std::expected<std::vector<std::optional<std::byte>>, PatternScanError>
diff --git a/source/utility/pattern_scan.cpp b/source/utility/pattern_scan.cpp
index b2ae08e..c15ff68 100644
--- a/source/utility/pattern_scan.cpp
+++ b/source/utility/pattern_scan.cpp
@@ -7,6 +7,33 @@
 namespace omath
 {
 
+    std::optional<std::span<std::byte>::const_iterator>
+    PatternScanner::scan_for_pattern(const std::string_view& pattern, const std::span<std::byte>& range)
+    {
+        const auto parsed_pattern = parse_pattern(pattern);
+
+        if (!parsed_pattern)
+            return std::nullopt;
+
+        const std::ptrdiff_t scan_size =
+                static_cast<std::ptrdiff_t>(range.size()) - static_cast<std::ptrdiff_t>(pattern.size());
+
+        for (std::ptrdiff_t i = 0; i < scan_size; i++)
+        {
+            bool found = true;
+
+            for (std::ptrdiff_t j = 0; j < static_cast<std::ptrdiff_t>(pattern.size()); j++)
+            {
+                found = parsed_pattern->at(j) == std::nullopt || parsed_pattern->at(j) == *(range.data() + i + j);
+
+                if (!found)
+                    break;
+            }
+            if (found)
+                return range.begin() + i;
+        }
+        return std::nullopt;
+    }
     std::expected<std::vector<std::optional<std::byte>>, PatternScanError>
     PatternScanner::parse_pattern(const std::string_view& pattern_string)
     {
@@ -39,14 +66,13 @@ namespace omath
 
             std::uint8_t value = 0;
             // ReSharper disable once CppTooWideScopeInitStatement
-            const auto [_, error_code] = std::from_chars(byte_str.data(), byte_str.data()+byte_str.size(), value, 16);
+            const auto [_, error_code] = std::from_chars(byte_str.data(), byte_str.data() + byte_str.size(), value, 16);
 
             if (error_code != std::errc{})
                 return std::unexpected(PatternScanError::INVALID_PATTERN_STRING);
 
             pattern.emplace_back(static_cast<std::byte>(value));
 
-
             start = end != pattern_string.end() ? std::next(end) : end;
         }
         return pattern;
diff --git a/tests/general/unit_test_pattern_scan.cpp b/tests/general/unit_test_pattern_scan.cpp
index 9b03486..d0da462 100644
--- a/tests/general/unit_test_pattern_scan.cpp
+++ b/tests/general/unit_test_pattern_scan.cpp
@@ -44,4 +44,11 @@ TEST(unit_test_pattern_scan, corner_case_3)
     EXPECT_EQ(result->at(1), std::nullopt);
     EXPECT_EQ(result->at(2), std::nullopt);
     EXPECT_EQ(result->at(3), static_cast<std::byte>(0xE9));
+}
+
+TEST(unit_test_pattern_scan, corner_case_4)
+{
+    const auto result = omath::PatternScanner::parse_pattern("X ? ?? E9 ");
+
+    EXPECT_FALSE(result.has_value());
 }
\ No newline at end of file

From 7bb23d3f7a1818a0a6ba56b76fd5b191efa1e4c8 Mon Sep 17 00:00:00 2001
From: Orange <orange-cpp@yandex.ru>
Date: Sun, 5 Oct 2025 14:14:31 +0300
Subject: [PATCH 5/7] Uses parsed pattern size in pattern scan

Updates the pattern scan loop to iterate over the size of the parsed pattern, ensuring correct iteration when using parsed patterns.
---
 source/utility/pattern_scan.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/source/utility/pattern_scan.cpp b/source/utility/pattern_scan.cpp
index c15ff68..f17228f 100644
--- a/source/utility/pattern_scan.cpp
+++ b/source/utility/pattern_scan.cpp
@@ -22,7 +22,7 @@ namespace omath
         {
             bool found = true;
 
-            for (std::ptrdiff_t j = 0; j < static_cast<std::ptrdiff_t>(pattern.size()); j++)
+            for (std::ptrdiff_t j = 0; j < static_cast<std::ptrdiff_t>(parsed_pattern->size()); j++)
             {
                 found = parsed_pattern->at(j) == std::nullopt || parsed_pattern->at(j) == *(range.data() + i + j);
 

From 7329410f94142b4e22aba01a530e108d8dd0bbf5 Mon Sep 17 00:00:00 2001
From: Orange <orange-cpp@yandex.ru>
Date: Sun, 5 Oct 2025 15:54:54 +0300
Subject: [PATCH 6/7] Uses `std::ranges::find` for pattern scanning

Replaces `std::find` with `std::ranges::find` for improved code consistency and potentially better performance when dealing with ranges.
---
 source/utility/pattern_scan.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/source/utility/pattern_scan.cpp b/source/utility/pattern_scan.cpp
index f17228f..d46ffa9 100644
--- a/source/utility/pattern_scan.cpp
+++ b/source/utility/pattern_scan.cpp
@@ -43,7 +43,7 @@ namespace omath
 
         while (start != pattern_string.cend())
         {
-            const auto end = std::find(start, pattern_string.cend(), ' ');
+            const auto end = std::ranges::find(start, pattern_string.cend(), ' ');
 
             const auto sting_view_start = std::distance(pattern_string.cbegin(), start);
             const auto sting_view_end = std::distance(start, end);

From e93a6dc2143cc5439a3cdaaa0678cd78e38f59d9 Mon Sep 17 00:00:00 2001
From: Orange <orange-cpp@yandex.ru>
Date: Sun, 5 Oct 2025 15:56:35 +0300
Subject: [PATCH 7/7] Includes header for fixed-width integer types

Adds `#include ` to ensure platform-independent use of fixed-width integer types.
---
 source/utility/pattern_scan.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/source/utility/pattern_scan.cpp b/source/utility/pattern_scan.cpp
index d46ffa9..8e37c90 100644
--- a/source/utility/pattern_scan.cpp
+++ b/source/utility/pattern_scan.cpp
@@ -3,7 +3,7 @@
 //
 #include "omath/utility/pattern_scan.hpp"
 #include <charconv>
-
+#include <cstdint>
 namespace omath
 {