impr: Replace horrible pattern extra data class with a more modular system

lib/libimhex/include/hex/api/content_registry.hpp

@@ -262,6 +262,18 @@ namespace hex {
 
             }
 
+            /**
+             * @brief Provides access to the current provider's pattern language runtime
+             * @return Runtime
+             */
+            pl::PatternLanguage& getRuntime();
+
+            /**
+             * @brief Provides access to the current provider's pattern language runtime's lock
+             * @return Lock
+             */
+            std::scoped_lock<std::mutex> getRuntimeLock();
+
             /**
              * @brief Configures the pattern language runtime using ImHex's default settings
              * @param runtime The pattern language runtime to configure
@@ -440,7 +452,7 @@ namespace hex {
                 add(impl::Entry {
                     unlocalizedCategory.c_str(),
                     unlocalizedName.c_str(),
-                    [=] {
+                    [=, ...args = std::forward<Args>(args)] mutable {
                         auto node = std::make_unique<T>(std::forward<Args>(args)...);
                         node->setUnlocalizedName(unlocalizedName);
                         return node;

lib/libimhex/include/hex/api/event.hpp

@@ -94,7 +94,7 @@ namespace hex {
          * @param token Token returned by subscribe
          */
         static void unsubscribe(const EventList::iterator &token) noexcept {
-            s_events.remove(*token);
+            s_events.erase(token);
         }
 
         /**
@@ -167,6 +167,7 @@ namespace hex {
     EVENT_DEF(EventPatternEditorChanged, const std::string&);
     EVENT_DEF(EventStoreContentDownloaded, const std::fs::path&);
     EVENT_DEF(EventStoreContentRemoved, const std::fs::path&);
+    EVENT_DEF(EventImHexClosing);
 
     EVENT_DEF(RequestOpenWindow, std::string);
     EVENT_DEF(RequestSelectionChange, Region);

lib/libimhex/include/hex/providers/provider_data.hpp

@@ -0,0 +1,78 @@
+#pragma once
+
+#include <hex/api/imhex_api.hpp>
+#include <hex/api/event.hpp>
+#include <hex/providers/provider.hpp>
+
+#include <concepts>
+#include <map>
+#include <utility>
+
+namespace hex {
+
+    template<typename T>
+    class PerProvider {
+    public:
+        PerProvider() { this->onCreate(); }
+        PerProvider(const PerProvider&) = delete;
+        PerProvider(PerProvider&&) = delete;
+        PerProvider& operator=(const PerProvider&) = delete;
+        PerProvider& operator=(PerProvider&&) = delete;
+
+        PerProvider(T data) : m_data({ { ImHexApi::Provider::get(), std::move(data) } }) { this->onCreate(); }
+
+        ~PerProvider() = default;
+
+        T* operator->() {
+            return &this->get();
+        }
+
+        const T* operator->() const {
+            return &this->get();
+        }
+
+        T& get(prv::Provider *provider = ImHexApi::Provider::get()) {
+            return this->m_data[provider];
+        }
+
+        const T& get(prv::Provider *provider = ImHexApi::Provider::get()) const {
+            return this->m_data[provider];
+        }
+
+        T& operator*() {
+            return this->get();
+        }
+
+        const T& operator*() const {
+            return this->get();
+        }
+
+        PerProvider& operator=(T data) {
+            this->m_data = std::move(data);
+            return *this;
+        }
+
+        operator T&() {
+            return this->get();
+        }
+
+    private:
+        void onCreate() {
+            (void)EventManager::subscribe<EventProviderOpened>([this](prv::Provider *provider) {
+                this->m_data.emplace(provider, T());
+            });
+
+            (void)EventManager::subscribe<EventProviderClosed>([this](prv::Provider *provider){
+                this->m_data.erase(provider);
+            });
+
+            EventManager::subscribe<EventImHexClosing>([this] {
+                this->m_data.clear();
+            });
+        }
+
+    private:
+        std::map<prv::Provider *, T> m_data;
+    };
+
+}

lib/libimhex/include/hex/ui/view.hpp

@@ -13,6 +13,7 @@
 #include <hex/api/imhex_api.hpp>
 #include <hex/api/event.hpp>
 #include <hex/providers/provider.hpp>
+#include <hex/providers/provider_data.hpp>
 #include <hex/helpers/utils.hpp>
 
 #include <hex/api/localization.hpp>

lib/libimhex/source/api/content_registry.cpp

@@ -259,6 +259,18 @@ namespace hex {
             return functionName;
         }
 
+        pl::PatternLanguage& getRuntime() {
+            static PerProvider<pl::PatternLanguage> runtime;
+
+            return *runtime;
+        }
+
+        std::scoped_lock<std::mutex> getRuntimeLock() {
+            static std::mutex runtimeLock;
+
+            return std::scoped_lock(runtimeLock);
+        }
+
         void configureRuntime(pl::PatternLanguage &runtime, prv::Provider *provider) {
             runtime.reset();