From f17d36dcd30928e83d8f5097a6c05cea5c27abfd 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 064edf9ef1c2b596d703fd2f4ae5421737808b86 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 160b51da944d6430d37c190d9c34bfa23b972fb9 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 06f9a8c9eed45529b13c8477fdea9abb1164e3a5 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 bd585b5412e5210a98b76b457e7dcaad380782cb 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 8021050fad9ab6152019c916b1a36089af7f9799 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 ec876ea292971136b320864302292625cd470fba 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
 {