feat: Offset2ID

Author: shad0wshayd3

include/REL/IDDB.h

@@ -29,6 +29,12 @@ namespace REL
 			V5 = 5
 		};
 
+		struct MAPPING
+		{
+			std::uint64_t id;
+			std::uint64_t offset;
+		};
+
 		IDDB();
 
 		std::uint64_t offset(std::uint64_t a_id) const;
@@ -38,17 +44,18 @@ namespace REL
 		class HEADER_V2;
 		class HEADER_V5;
 
-		struct MAPPING
-		{
-			std::uint64_t id;
-			std::uint64_t offset;
-		};
-
 		void load_v0();
 		void load_v2(STREAM& a_stream);
 		void load_v5(STREAM& a_stream);
 		void unpack_file(STREAM& a_stream, const HEADER_V2& a_header);
 
+	protected:
+		// clang-format off
+		template <class T> std::span<T>      get_id2offset() const noexcept;
+		template <> std::span<MAPPING>       get_id2offset() const noexcept { return m_v0; }
+		template <> std::span<std::uint32_t> get_id2offset() const noexcept { return m_v5; }
+		// clang-format on
+
 	private:
 		std::filesystem::path    m_path;
 		Loader                   m_loader{ Loader::None };

include/REL/Offset2ID.h

@@ -0,0 +1,83 @@
+#pragma once
+
+#include "REX/BASE.h"
+
+#include "REL/IDDB.h"
+
+namespace REL
+{
+	template <class T>
+	class Offset2ID
+	{
+	public:
+		using value_type = T;
+		using container_type = std::vector<value_type>;
+		using size_type = typename container_type::size_type;
+		using const_iterator = typename container_type::const_iterator;
+		using const_reverse_iterator = typename container_type::const_reverse_iterator;
+
+		template <class ExecutionPolicy>
+		explicit Offset2ID(ExecutionPolicy&& a_policy)  // NOLINT(bugprone-forwarding-reference-overload)
+			requires(std::is_execution_policy_v<std::decay_t<ExecutionPolicy>>)
+		{
+			const auto iddb = IDDB::GetSingleton();
+			const auto id2offset = iddb->get_id2offset<T>();
+			_offset2id.reserve(id2offset.size());
+			_offset2id.insert(_offset2id.begin(), id2offset.begin(), id2offset.end());
+			std::sort(a_policy, _offset2id.begin(), _offset2id.end(), [](auto&& a_lhs, auto&& a_rhs) {
+				return a_lhs.offset < a_rhs.offset;
+			});
+		}
+
+		Offset2ID() :
+			Offset2ID(std::execution::sequenced_policy{})
+		{}
+
+		[[nodiscard]] std::uint64_t operator()(std::size_t a_offset) const
+		{
+			if (_offset2id.empty()) {
+				REX::FAIL("No Address Library has been loaded!");
+			}
+
+			const value_type elem{ 0, a_offset };
+			const auto       it = std::lower_bound(
+                _offset2id.begin(),
+                _offset2id.end(),
+                elem,
+                [](auto&& a_lhs, auto&& a_rhs) {
+                    return a_lhs.offset < a_rhs.offset;
+                });
+			if (it == _offset2id.end()) {
+				const auto mod = Module::GetSingleton();
+				const auto version = mod->version();
+				REX::FAIL(
+					"Failed to find Address Library ID for offset!\n"
+					"Invalid offset: 0x{:08X}\n"
+					"Game Version: {}",
+					a_offset, version.string());
+			}
+
+			return it->id;
+		}
+
+		[[nodiscard]] const_iterator begin() const noexcept { return _offset2id.begin(); }
+		[[nodiscard]] const_iterator cbegin() const noexcept { return _offset2id.cbegin(); }
+
+		[[nodiscard]] const_iterator end() const noexcept { return _offset2id.end(); }
+		[[nodiscard]] const_iterator cend() const noexcept { return _offset2id.cend(); }
+
+		[[nodiscard]] const_reverse_iterator rbegin() const noexcept { return _offset2id.rbegin(); }
+		[[nodiscard]] const_reverse_iterator crbegin() const noexcept { return _offset2id.crbegin(); }
+
+		[[nodiscard]] const_reverse_iterator rend() const noexcept { return _offset2id.rend(); }
+		[[nodiscard]] const_reverse_iterator crend() const noexcept { return _offset2id.crend(); }
+
+		[[nodiscard]] size_type size() const noexcept { return _offset2id.size(); }
+
+	protected:
+		friend class IDDB;
+
+	private:
+		container_type _offset2id;
+	};
+}

include/REL/REL.h

@@ -9,6 +9,7 @@
 #include "REL/IDDB.h"
 #include "REL/Module.h"
 #include "REL/Offset.h"
+#include "REL/Offset2ID.h"
 #include "REL/Pattern.h"
 #include "REL/Relocation.h"
 #include "REL/Segment.h"