feat: Move hashes into plugin, merged in extra hashes plugin

lib/libimhex/CMakeLists.txt

@@ -40,6 +40,7 @@ set(LIBIMHEX_SOURCES
         source/helpers/debugging.cpp
 
         source/providers/provider.cpp
+        source/providers/memory_provider.cpp
         source/providers/undo/stack.cpp
 
         source/ui/imgui_imhex_extensions.cpp

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

@@ -0,0 +1,47 @@
+#pragma once
+
+#include <hex/providers/provider.hpp>
+
+namespace hex::prv {
+
+    /**
+     * This is a simple mock provider that can be used to pass in-memory data to APIs that require a provider.
+     * It's NOT a provider that can be loaded by the user.
+     */
+    class MemoryProvider : public hex::prv::Provider {
+    public:
+        MemoryProvider() = default;
+        explicit MemoryProvider(std::vector<u8> data) : m_data(std::move(data)) { }
+        ~MemoryProvider() override = default;
+
+        [[nodiscard]] bool isAvailable()        const override { return true;           }
+        [[nodiscard]] bool isReadable()         const override { return true;           }
+        [[nodiscard]] bool isWritable()         const override { return true;           }
+        [[nodiscard]] bool isResizable()        const override { return true;           }
+        [[nodiscard]] bool isSavable()          const override { return m_name.empty(); }
+        [[nodiscard]] bool isSavableAsRecent()  const override { return false;          }
+
+        [[nodiscard]] bool open() override;
+        void close() override { }
+
+        void readRaw(u64 offset, void *buffer, size_t size) override;
+        void writeRaw(u64 offset, const void *buffer, size_t size) override;
+        [[nodiscard]] u64 getActualSize() const override { return m_data.size(); }
+
+        void resizeRaw(u64 newSize) override;
+        void insertRaw(u64 offset, u64 size) override;
+        void removeRaw(u64 offset, u64 size) override;
+
+        [[nodiscard]] std::string getName() const override { return ""; }
+
+        [[nodiscard]] std::string getTypeName() const override { return "MemoryProvider"; }
+
+    private:
+        void renameFile();
+
+    private:
+        std::vector<u8> m_data;
+        std::string m_name;
+    };
+
+}

lib/libimhex/source/providers/memory_provider.cpp

@@ -0,0 +1,71 @@
+#include <hex/providers/memory_provider.hpp>
+
+#include <cstring>
+
+namespace hex::prv {
+
+    bool MemoryProvider::open() {
+        if (m_data.empty()) {
+            m_data.resize(1);
+        }
+
+        return true;
+    }
+
+    void MemoryProvider::readRaw(u64 offset, void *buffer, size_t size) {
+        auto actualSize = this->getActualSize();
+        if (actualSize == 0 || (offset + size) > actualSize || buffer == nullptr || size == 0)
+            return;
+
+        std::memcpy(buffer, &m_data.front() + offset, size);
+    }
+
+    void MemoryProvider::writeRaw(u64 offset, const void *buffer, size_t size) {
+        if ((offset + size) > this->getActualSize() || buffer == nullptr || size == 0)
+            return;
+
+        std::memcpy(&m_data.front() + offset, buffer, size);
+    }
+
+    void MemoryProvider::resizeRaw(u64 newSize) {
+        m_data.resize(newSize);
+    }
+
+    void MemoryProvider::insertRaw(u64 offset, u64 size) {
+        auto oldSize = this->getActualSize();
+        this->resizeRaw(oldSize + size);
+
+        std::vector<u8> buffer(0x1000);
+        const std::vector<u8> zeroBuffer(0x1000);
+
+        auto position = oldSize;
+        while (position > offset) {
+            const auto readSize = std::min<size_t>(position - offset, buffer.size());
+
+            position -= readSize;
+
+            this->readRaw(position, buffer.data(), readSize);
+            this->writeRaw(position, zeroBuffer.data(), readSize);
+            this->writeRaw(position + size, buffer.data(), readSize);
+        }
+    }
+
+    void MemoryProvider::removeRaw(u64 offset, u64 size) {
+        auto oldSize = this->getActualSize();
+        std::vector<u8> buffer(0x1000);
+
+        const auto newSize = oldSize - size;
+        auto position = offset;
+        while (position < newSize) {
+            const auto readSize = std::min<size_t>(newSize - position, buffer.size());
+
+            this->readRaw(position + size, buffer.data(), readSize);
+            this->writeRaw(position, buffer.data(), readSize);
+
+            position += readSize;
+        }
+
+        this->resizeRaw(oldSize - size);
+    }
+
+}