update for patch 1.10

remove/comment obsolete code
some cleanups

hooking/Hooking.Patterns.h

@@ -11,108 +11,97 @@
 
 #include <sstream>
 
-namespace hook
-{
-	class pattern_match
-	{
-	private:
-		void* m_pointer;
-
-	public:
-		inline pattern_match(void* pointer)
-		{
-			m_pointer = pointer;
-		}
-
-		template<typename T>
-		T get(int offset)
-		{
-			char* ptr = reinterpret_cast<char*>(m_pointer);
-			return reinterpret_cast<T>(ptr + offset);
-		}
-
-    template<typename T>
-    T extract(int offset) {
-      char* address = get<char*>(offset);
-      return reinterpret_cast<T>(address + *(int32_t*)address + 4);
-    }
+namespace hook {
+class pattern_match {
+ private:
+  void* m_pointer;
 
+ public:
+  inline pattern_match(void* pointer) { m_pointer = pointer; }
 
-		template<typename T>
-		T* get()
-		{
-			return get<T>(0);
-		}
-	};
+  template <typename T>
+  T get(int offset) {
+    char* ptr = reinterpret_cast<char*>(m_pointer);
+    return reinterpret_cast<T>(ptr + offset);
+  }
 
-	class pattern
-	{
-	private:
-		std::string m_bytes;
-		std::string m_mask;
+  template <typename T>
+  T extract(int offset) {
+    char* address = get<char*>(offset);
+    return reinterpret_cast<T>(address + *(int32_t*)address + 4);
+  }
 
-		uint64_t m_hash;
+  template <typename T>
+  T* get() {
+    return get<T>(0);
+  }
+};
 
-		size_t m_size;
+class pattern {
+ private:
+  std::string m_bytes;
+  std::string m_mask;
+  std::string orginal_pattern_;
 
-		std::vector<pattern_match> m_matches;
+  uint64_t m_hash;
 
-		bool m_matched;
+  size_t m_size;
 
-	private:
-		void Initialize(const char* pattern, size_t length);
+  std::vector<pattern_match> m_matches;
 
-		bool ConsiderMatch(uintptr_t offset);
+  bool m_matched;
 
-		void EnsureMatches(int maxCount);
+ private:
+  void Initialize(const char* pattern, size_t length);
 
-	public:
-		template<size_t Len>
-		pattern(const char (&pattern)[Len])
-		{
-			Initialize(pattern, Len);
-		}
+  bool ConsiderMatch(uintptr_t offset);
 
-		inline pattern& count(int expected)
-		{
-			if (!m_matched)
-			{
-				EnsureMatches(expected);
-			}
+  void EnsureMatches(int maxCount);
 
-			if (m_matches.size() != expected) {
-				std::stringstream message;
-				message << m_matches.size() << " != " << expected << " " << m_bytes;
-        MessageBoxA(NULL, message.str().c_str(), "MatchesCountError", MB_OK | MB_ICONEXCLAMATION);
-			};
+ public:
+  template <size_t Len>
+  pattern(const char (&pattern)[Len]) {
+    orginal_pattern_ = pattern;
+    Initialize(pattern, Len);
+  }
 
-			return *this;
-		}
+  inline pattern& count(int expected) {
+    if (!m_matched) {
+      EnsureMatches(expected);
+    }
 
-		inline size_t size()
-		{
-			if (!m_matched)
-			{
-				EnsureMatches(INT_MAX);
-			}
+    if (m_matches.size() != expected) {
+      std::stringstream message;
+      message << "pattern: " << orginal_pattern_ << std::endl
+              << "found: " << m_matches.size() << " expected: " << expected;
+      MessageBoxA(NULL, message.str().c_str(), "Hook: MatchesCountCheckError",
+                  MB_OK | MB_ICONEXCLAMATION);
+      abort();
+    };
+
+    return *this;
+  }
+
+  inline size_t size() {
+    if (!m_matched) {
+      EnsureMatches(INT_MAX);
+    }
 
-			return m_matches.size();
-		}
+    return m_matches.size();
+  }
 
-		inline pattern_match& get(int index)
-		{
-			if (!m_matched)
-			{
-				EnsureMatches(INT_MAX);
-			}
+  inline pattern_match& get(int index) {
+    if (!m_matched) {
+      EnsureMatches(INT_MAX);
+    }
 
-			return m_matches[index];
-		}
+    return m_matches[index];
+  }
 
-	public:
-		// define a hint
-		static void hint(uint64_t hash, uintptr_t address);
-	};
+ public:
+  // define a hint
+  static void hint(uint64_t hash, uintptr_t address);
+};
 }
 
 void Citizen_PatternSaveHint(uint64_t hash, uintptr_t hint);