impr: Run data processor in a worker task

lib/libimhex/include/hex/data_processor/node.hpp

@@ -12,6 +12,7 @@
 
 #include <nlohmann/json_fwd.hpp>
 #include <imgui.h>
+#include <hex/providers/provider_data.hpp>
 
 namespace hex::prv {
     class Provider;
@@ -42,8 +43,9 @@ namespace hex::dp {
             m_overlay = overlay;
         }
 
-        virtual void drawNode() { }
+        void draw();
         virtual void process() = 0;
+        virtual void reset() { }
 
         virtual void store(nlohmann::json &j) const { hex::unused(j); }
         virtual void load(const nlohmann::json &j) { hex::unused(j); }
@@ -80,6 +82,11 @@ namespace hex::dp {
         void setIntegerOnOutput(u32 index, i128 integer);
         void setFloatOnOutput(u32 index, double floatingPoint);
 
+        static void interrupt();
+
+    protected:
+        virtual void drawNode() { }
+
     private:
         int m_id;
         UnlocalizedString m_unlocalizedTitle, m_unlocalizedName;
@@ -90,45 +97,16 @@ namespace hex::dp {
 
         static int s_idCounter;
 
-        Attribute& getAttribute(u32 index) {
-            if (index >= this->getAttributes().size())
-                throw std::runtime_error("Attribute index out of bounds!");
-
-            return this->getAttributes()[index];
-        }
-
-        Attribute *getConnectedInputAttribute(u32 index) {
-            const auto &connectedAttribute = this->getAttribute(index).getConnectedAttributes();
-
-            if (connectedAttribute.empty())
-                return nullptr;
-
-            return connectedAttribute.begin()->second;
-        }
-
-        void markInputProcessed(u32 index) {
-            const auto &[iter, inserted] = m_processedInputs.insert(index);
-            if (!inserted)
-                throwNodeError("Recursion detected!");
-        }
-
-        void unmarkInputProcessed(u32 index) {
-            m_processedInputs.erase(index);
-        }
+        Attribute& getAttribute(u32 index);
+        Attribute *getConnectedInputAttribute(u32 index);
+        void markInputProcessed(u32 index);
+        void unmarkInputProcessed(u32 index);
 
     protected:
-        [[noreturn]] void throwNodeError(const std::string &message) {
-            throw NodeError { this, message };
-        }
+        [[noreturn]] void throwNodeError(const std::string &message);
 
         void setOverlayData(u64 address, const std::vector<u8> &data);
-
-        void setAttributes(std::vector<Attribute> attributes) {
-            m_attributes = std::move(attributes);
-
-            for (auto &attr : m_attributes)
-                attr.setParentNode(this);
-        }
+        void setAttributes(std::vector<Attribute> attributes);
     };
 
 }

lib/libimhex/source/data_processor/node.cpp

@@ -8,12 +8,18 @@
 namespace hex::dp {
 
     int Node::s_idCounter = 1;
+    static std::atomic_bool s_interrupted;
 
     Node::Node(UnlocalizedString unlocalizedTitle, std::vector<Attribute> attributes) : m_id(s_idCounter++), m_unlocalizedTitle(std::move(unlocalizedTitle)), m_attributes(std::move(attributes)) {
         for (auto &attr : m_attributes)
             attr.setParentNode(this);
     }
 
+    void Node::draw() {
+        this->drawNode();
+    }
+
+
     const std::vector<u8>& Node::getBufferOnInput(u32 index) {
         auto attribute = this->getConnectedInputAttribute(index);
 
@@ -148,9 +154,56 @@ namespace hex::dp {
         m_overlay->getData() = data;
     }
 
+    [[noreturn]] void Node::throwNodeError(const std::string &message) {
+        throw NodeError { this, message };
+    }
+
+    void Node::setAttributes(std::vector<Attribute> attributes) {
+        m_attributes = std::move(attributes);
+
+        for (auto &attr : m_attributes)
+            attr.setParentNode(this);
+    }
+
     void Node::setIdCounter(int id) {
         if (id > s_idCounter)
             s_idCounter = id;
     }
 
+    Attribute& Node::getAttribute(u32 index) {
+        if (index >= this->getAttributes().size())
+            throw std::runtime_error("Attribute index out of bounds!");
+
+        return this->getAttributes()[index];
+    }
+
+    Attribute *Node::getConnectedInputAttribute(u32 index) {
+        const auto &connectedAttribute = this->getAttribute(index).getConnectedAttributes();
+
+        if (connectedAttribute.empty())
+            return nullptr;
+
+        return connectedAttribute.begin()->second;
+    }
+
+    void Node::markInputProcessed(u32 index) {
+        const auto &[iter, inserted] = m_processedInputs.insert(index);
+        if (!inserted)
+            throwNodeError("Recursion detected!");
+
+        if (s_interrupted) {
+            s_interrupted = false;
+            throwNodeError("Execution interrupted!");
+        }
+    }
+
+    void Node::unmarkInputProcessed(u32 index) {
+        m_processedInputs.erase(index);
+    }
+
+    void Node::interrupt() {
+        s_interrupted = true;
+    }
+
+
 }