Class AlgorithmMyers

plugins/diffing/source/content/diffing_algorithms.cpp:79–194

    };

    class AlgorithmMyers : public Algorithm {
    public:
        AlgorithmMyers() : Algorithm("hex.diffing.algorithm.myers.name", "hex.diffing.algorithm.myers.description") {}

        [[nodiscard]] std::vector<DiffTree> analyze(prv::Provider *providerA, prv::Provider *providerB) const override {
            DiffTree differencesA, differencesB;

            EdlibAlignConfig edlibConfig;
            edlibConfig.k = -1;
            edlibConfig.additionalEqualities = nullptr;
            edlibConfig.additionalEqualitiesLength = 0;
            edlibConfig.mode = EdlibAlignMode::EDLIB_MODE_NW;
            edlibConfig.task = EdlibAlignTask::EDLIB_TASK_PATH;

            const auto providerAStart = providerA->getBaseAddress();
            const auto providerBStart = providerB->getBaseAddress();
            const auto providerAEnd = providerAStart + providerA->getActualSize();
            const auto providerBEnd = providerBStart + providerB->getActualSize();

            const auto windowStart = std::max(providerAStart, providerBStart);
            const auto windowEnd   = std::min(providerAEnd, providerBEnd);

            auto &task = TaskManager::getCurrentTask();

            if (providerAStart > providerBStart) {
                differencesA.insert({ providerBStart, providerAStart }, DifferenceType::Deletion);
                differencesB.insert({ providerBStart, providerAStart }, DifferenceType::Deletion);
            } else if (providerAStart < providerBStart) {
                differencesA.insert({ providerAStart, providerBStart }, DifferenceType::Insertion);
                differencesB.insert({ providerAStart, providerBStart }, DifferenceType::Insertion);
            }

            for (u64 address = windowStart; address < windowEnd; address += m_windowSize) {
                if (task.wasInterrupted())
                    break;

                auto currWindowSizeA = std::min<u64>(m_windowSize, providerA->getActualSize() - address);
                auto currWindowSizeB = std::min<u64>(m_windowSize, providerB->getActualSize() - address);
                std::vector<u8> dataA(currWindowSizeA, 0x00), dataB(currWindowSizeB, 0x00);

                providerA->read(address, dataA.data(), dataA.size());
                providerB->read(address, dataB.data(), dataB.size());

                const auto commonSize = std::min(dataA.size(), dataB.size());
                EdlibAlignResult result = edlibAlign(
                    reinterpret_cast<const char*>(dataA.data()), commonSize,
                    reinterpret_cast<const char*>(dataB.data()), commonSize,
                    edlibConfig
                );

                auto currentOperation = DifferenceType(0xFF);
                Region regionA = {}, regionB = {};
                u64 currentAddressA = address, currentAddressB = address;

                const auto insertDifference = [&] {
                    switch (currentOperation) {
                        using enum DifferenceType;