Class AlgorithmSimple

plugins/diffing/source/content/diffing_algorithms.cpp:20–77

    using namespace wolv::literals;

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

        [[nodiscard]] std::vector<DiffTree> analyze(prv::Provider *providerA, prv::Provider *providerB) const override {
            wolv::container::IntervalTree<DifferenceType> differences;

            // Set up readers for both providers
            auto readerA = prv::ProviderReader(providerA);
            auto readerB = prv::ProviderReader(providerB);

            auto &task = TaskManager::getCurrentTask();

            // Iterate over both providers and compare the bytes
            for (auto itA = readerA.begin(), itB = readerB.begin(); itA < readerA.end() && itB < readerB.end(); ++itA, ++itB) {
                // Stop comparing if the diff task was canceled
                if (task.wasInterrupted())
                    break;

                // If the bytes are different, find the end of the difference
                if (*itA != *itB) {
                    u64 start = itA.getAddress();
                    size_t size = 0;

                    while (itA != readerA.end() && itB != readerB.end() && *itA != *itB) {
                        ++itA;
                        ++itB;
                        ++size;
                    }

                    // Add the difference to the list
                    differences.emplace({ start, (start + size) - 1 }, DifferenceType::Mismatch);
                }

                // Update the progress bar
                task.update(itA.getAddress());
            }

            auto otherDifferences = differences;

            // If one provider is larger than the other, add the extra bytes to the list
            if (providerA->getActualSize() != providerB->getActualSize()) {
                auto endA = providerA->getActualSize() + 1;
                auto endB = providerB->getActualSize() + 1;

                if (endA > endB) {
                    differences.emplace({ endB, endA }, DifferenceType::Insertion);
                    otherDifferences.emplace({ endB, endA }, DifferenceType::Deletion);
                }
                else {
                    differences.emplace({ endA, endB }, DifferenceType::Insertion);
                    otherDifferences.emplace({ endB, endA }, DifferenceType::Insertion);
                }
            }

            return { differences, otherDifferences };
        }
    };